import java.io.*; 
import java.util.*; 
import java.util.function.*; 

class Fruit { 
    public AccountKey getAccountKey() { return null; } 
    public FactionKey getFactionKey() { return null; } 
} 

class AccountKey { 
} 


class BookKey {} 
class BrokerKey {} 
class FactionKey {} 
class EntityKey {} 
class InstrumentKey {} 
class PositionKey {} 
class OrderKey {} 
interface CollectionManager {} 

class ArrayUtil 
{ 
    public static <T, R> R[] map(T[] a, 
                                 Function<T,R> f, 
                                 IntFunction <R[]> ctor) 
    { 
        return null; 
    } 
} 


abstract class AbstractSelection 
    implements Selection 
{ 
} 

abstract class AbstractCompoundSelection<S extends Selection> 
    extends AbstractSelection 
{ 
    protected List<S> getSelections() 
    { 
        return null; 
    } 
} 

abstract class AbstractAndSelection<S extends Selection> 
    extends AbstractCompoundSelection<S> 
{ 
} 

abstract class AbstractOrSelection<S extends Selection> 
    extends AbstractCompoundSelection<S> 
{ 
} 

abstract class AbstractNotSelection<S extends Selection> 
    extends AbstractCompoundSelection<S> 
{ 
    protected S getSelectionToInvert() 
    { 
        return null; 
    } 
} 

interface Selector 
{ 
    public static interface AccountLegSelector 
        extends Selector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                QuarterFruitLegSelector 
    { 
        public Selection.AccountLegSelection getSelection(); 
    } 

    public static interface AccountSelector 
        extends Selector, 
                AccountLegSelector, 
                FactionAccountSelector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                FruitSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.AccountSelection getSelection(); 
    } 

    public static interface BookSelector 
        extends Selector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                FruitSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.BookSelection getSelection(); 
    } 

    public static interface EntityLegSelector 
        extends Selector, 
                AccountLegSelector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                QuarterFruitLegSelector 
    { 
        public Selection.EntityLegSelection getSelection(); 
    } 

    public static interface EntitySelector 
        extends Selector, 
                AccountLegSelector, 
                AccountSelector, 
                EntityLegSelector, 
                EntityGangSelector, 
                FactionAccountSelector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                FruitSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.EntitySelection getSelection(); 
    } 

    public static interface EntityGangSelector 
        extends Selector, 
                AccountLegSelector, 
                AccountSelector, 
                FactionAccountSelector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                FruitSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.EntityGangSelection getSelection(); 
    } 

    public static interface FactionAccountSelector 
        extends Selector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                FruitSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.FactionAccountSelection getSelection(); 
    } 

    public static interface FactionLegSelector 
        extends Selector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                QuarterFruitLegSelector 
    { 
        public Selection.FactionLegSelection getSelection(); 
    } 

    public static interface FactionSelector 
        extends Selector, 
                FactionAccountSelector, 
                FactionLegSelector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                FruitSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.FactionSelection getSelection(); 
    } 

    public static interface LegSelector 
        extends Selector, 
                AccountLegSelector, 
                EntityLegSelector, 
                FactionLegSelector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                QuarterFruitLegSelector 
    { 
        public Selection.LegSelection getSelection(); 
    } 

    public static interface FruitLegAppleSauceSelector 
        extends Selector 
    { 
        public Selection.FruitLegAppleSauceSelection getSelection(); 
    } 

    public static interface FruitLegSelector 
        extends Selector, 
                FruitLegAppleSauceSelector, 
                QuarterFruitLegSelector 
    { 
        public Selection.FruitLegSelection getSelection(); 
    } 

    public static interface FruitSelector 
        extends Selector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.FruitSelection getSelection(); 
    } 

    public static interface GangSelector 
        extends Selector, 
                AccountLegSelector, 
                AccountSelector, 
                EntityGangSelector, 
                FactionAccountSelector, 
                FruitLegAppleSauceSelector, 
                FruitLegSelector, 
                FruitSelector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector, 
                QuarterGangSelector 
    { 
        public Selection.GangSelection getSelection(); 
    } 

    public static interface QuarterFruitLegSelector 
        extends Selector 
    { 
        public Selection.QuarterFruitLegSelection getSelection(); 
    } 

    public static interface QuarterFruitSelector 
        extends Selector, 
                QuarterFruitLegSelector 
    { 
        public Selection.QuarterFruitSelection getSelection(); 
    } 

    public static interface QuarterGangSelector 
        extends Selector, 
                QuarterFruitLegSelector, 
                QuarterFruitSelector 
    { 
        public Selection.QuarterGangSelection getSelection(); 
    } 
} 

public interface Selection 
{ 
    public default void serialize(final OutputStream out) 
        throws IOException, 
               UnsupportedOperationException 
    { 
        throw new UnsupportedOperationException(); 
    } 

    public default <S extends Selection> void deserialize(final InputStream in, 
                                                          final Class<S> klass) 
        throws IOException, 
               UnsupportedOperationException 
    { 
        throw new UnsupportedOperationException(); 
    } 

    public default void serializeBinary(final DataOutput out) 
        throws IOException, 
               UnsupportedOperationException 
    { 
        throw new UnsupportedOperationException(); 
    } 

    public default <S extends Selection> void deserializeBinary(final DataInput in, 
                                                                final Class<S> klass) 
        throws IOException, 
               UnsupportedOperationException 
    { 
        throw new UnsupportedOperationException(); 
    } 

    public default boolean hasLegSelection() 
    { 
        return false; 
    } 

    public default String toString(CollectionManager cm) 
    { 
        throw new UnsupportedOperationException(); 
    } 

    public default String toInfixString(CollectionManager cm) 
    { 
        return toString(cm); 
    } 

    public default int compareTo(Selection that) 
    { 
        return 0; 
    } 

    public static interface AccountLegSelection 
        extends Selection, 
                Selector.AccountLegSelector, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                QuarterFruitLegSelection 
    { 
        public boolean matchesAccountLeg(final CollectionManager cm, final AccountKey account, final int leg); 

        public default AccountLegSelection getSelection() { return this; } 
    } 

    public static interface AccountSelection 
        extends Selection, 
                Selector.AccountSelector, 
                AccountLegSelection, 
                FactionAccountSelection, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                FruitSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesAccount(final CollectionManager cm, final AccountKey account); 

        public default AccountSelection getSelection() { return this; } 
    } 

    public static interface BookSelection 
        extends Selection, 
                Selector.BookSelector, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                FruitSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesBook(final CollectionManager cm, final BookKey book); 

        public default BookSelection getSelection() { return this; } 
    } 

    public static interface EntityLegSelection 
        extends Selection, 
                Selector.EntityLegSelector, 
                AccountLegSelection, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                QuarterFruitLegSelection 
    { 
        public boolean matchesEntityLeg(final CollectionManager cm, final EntityKey entity, final int leg); 

        public default EntityLegSelection getSelection() { return this; } 
    } 

    public static interface EntitySelection 
        extends Selection, 
                Selector.EntitySelector, 
                AccountLegSelection, 
                AccountSelection, 
                EntityLegSelection, 
                EntityGangSelection, 
                FactionAccountSelection, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                FruitSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesEntity(final CollectionManager cm, final EntityKey entity); 

        public default EntitySelection getSelection() { return this; } 
    } 

    public static interface EntityGangSelection 
        extends Selection, 
                Selector.EntityGangSelector, 
                AccountLegSelection, 
                AccountSelection, 
                FactionAccountSelection, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                FruitSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesEntityGang(final CollectionManager cm, final EntityKey entity, final BrokerKey gang); 

        public default EntityGangSelection getSelection() { return this; } 
    } 

    public static interface FactionAccountSelection 
        extends Selection, 
                Selector.FactionAccountSelector, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                FruitSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesFactionAccount(final CollectionManager cm, final FactionKey faction, final AccountKey account); 

        public default FactionAccountSelection getSelection() { return this; } 
    } 

    public static interface FactionLegSelection 
        extends Selection, 
                Selector.FactionLegSelector, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                QuarterFruitLegSelection 
    { 
        public boolean matchesFactionLeg(final CollectionManager cm, final FactionKey faction, final int leg); 

        public default FactionLegSelection getSelection() { return this; } 
    } 

    public static interface FactionSelection 
        extends Selection, 
                Selector.FactionSelector, 
                FactionAccountSelection, 
                FactionLegSelection, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                FruitSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesFaction(final CollectionManager cm, final FactionKey faction); 

        public default FactionSelection getSelection() { return this; } 
    } 

    public static interface LegSelection 
        extends Selection, 
                Selector.LegSelector, 
                AccountLegSelection, 
                EntityLegSelection, 
                FactionLegSelection, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                QuarterFruitLegSelection 
    { 
        public boolean matchesLeg(final CollectionManager cm, final int leg); 

        public default LegSelection getSelection() { return this; } 
    } 

    public static interface FruitLegAppleSauceSelection 
        extends Selection, 
                Selector.FruitLegAppleSauceSelector 
    { 
        public boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit positionQuark, final int leg, final InstrumentKey appleSauce); 

        public default FruitLegAppleSauceSelection getSelection() { return this; } 
    } 

    public static interface FruitLegSelection 
        extends Selection, 
                Selector.FruitLegSelector, 
                FruitLegAppleSauceSelection, 
                QuarterFruitLegSelection 
    { 
        public boolean matchesFruitLeg(final CollectionManager cm, final Fruit positionQuark, final int leg); 

        public default FruitLegSelection getSelection() { return this; } 
    } 

    public static interface FruitSelection 
        extends Selection, 
                Selector.FruitSelector, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesFruit(final CollectionManager cm, final Fruit positionQuark); 

        public default FruitSelection getSelection() { return this; } 

         public default boolean isRestrictsToBundle() { return false; } 

         public default boolean isRestrictsToBusinessUnit() { return false; } 
    } 

    public static interface GangSelection 
        extends Selection, 
                Selector.GangSelector, 
                AccountLegSelection, 
                AccountSelection, 
                EntityGangSelection, 
                FactionAccountSelection, 
                FruitLegAppleSauceSelection, 
                FruitLegSelection, 
                FruitSelection, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection, 
                QuarterGangSelection 
    { 
        public boolean matchesGang(final CollectionManager cm, final BrokerKey gang); 

        public default GangSelection getSelection() { return this; } 
    } 

    public static interface QuarterFruitLegSelection 
        extends Selection, 
                Selector.QuarterFruitLegSelector 
    { 
        public boolean matchesQuarterFruitLeg(final CollectionManager cm, final int quarter, final Fruit positionQuark, final int leg); 

        public default QuarterFruitLegSelection getSelection() { return this; } 
    } 

    public static interface QuarterFruitSelection 
        extends Selection, 
                Selector.QuarterFruitSelector, 
                QuarterFruitLegSelection 
    { 
        public boolean matchesQuarterFruit(final CollectionManager cm, final int quarter, final Fruit positionQuark); 

        public default QuarterFruitSelection getSelection() { return this; } 
    } 

    public static interface QuarterGangSelection 
        extends Selection, 
                Selector.QuarterGangSelector, 
                QuarterFruitLegSelection, 
                QuarterFruitSelection 
    { 
        public boolean matchesQuarterGang(final CollectionManager cm, final int quarter, final BrokerKey gang); 

        public default QuarterGangSelection getSelection() { return this; } 
    } 

    public static class AndAccountLegSelection 
        extends AbstractAndSelection<AccountLegSelection> 
        implements AbstractAccountLegSelection 
    { 
        public AndAccountLegSelection(AccountLegSelection... selections) 
        { 
        } 

        public boolean matchesAccountLeg(final CollectionManager cm, final AccountKey account, final int leg) 
        { 
            final List<AccountLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesAccountLeg(cm, account, leg)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrAccountLegSelection 
        extends AbstractOrSelection<AccountLegSelection> 
        implements AbstractAccountLegSelection 
    { 
        public OrAccountLegSelection(AccountLegSelection... selections) 
        { 
        } 

        public boolean matchesAccountLeg(CollectionManager cm, final AccountKey account, final int leg) 
        { 
            final List<AccountLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesAccountLeg(cm, account, leg)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotAccountLegSelection 
        extends AbstractNotSelection<AccountLegSelection> 
        implements AbstractAccountLegSelection 
    { 
        public NotAccountLegSelection(AccountLegSelection selection) 
        { 
        } 

        public boolean matchesAccountLeg(CollectionManager cm, final AccountKey account, final int leg) 
        { 
            return !getSelectionToInvert().matchesAccountLeg(cm, account, leg); 
        } 

    } 

    public static AccountLegSelection and(AccountLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndAccountLegSelection(selections); 
        } 
    } 

    public static AccountLegSelection and(Selector.AccountLegSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), AccountLegSelection[]::new)); 
    } 

    public static AccountLegSelection or(AccountLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrAccountLegSelection(selections); 
        } 
    } 

    public static AccountLegSelection or(Selector.AccountLegSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), AccountLegSelection[]::new)); 
    } 

    public static AccountLegSelection not(Selector.AccountLegSelector selector) 
    { 
        return new NotAccountLegSelection(selector.getSelection()); 
    } 

    public static class AndAccountSelection 
        extends AbstractAndSelection<AccountSelection> 
        implements AbstractAccountSelection 
    { 
        public AndAccountSelection(AccountSelection... selections) 
        { 
        } 

        public boolean matchesAccount(final CollectionManager cm, final AccountKey account) 
        { 
            final List<AccountSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesAccount(cm, account)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrAccountSelection 
        extends AbstractOrSelection<AccountSelection> 
        implements AbstractAccountSelection 
    { 
        public OrAccountSelection(AccountSelection... selections) 
        { 
        } 

        public boolean matchesAccount(CollectionManager cm, final AccountKey account) 
        { 
            final List<AccountSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesAccount(cm, account)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotAccountSelection 
        extends AbstractNotSelection<AccountSelection> 
        implements AbstractAccountSelection 
    { 
        public NotAccountSelection(AccountSelection selection) 
        { 
        } 

        public boolean matchesAccount(CollectionManager cm, final AccountKey account) 
        { 
            return !getSelectionToInvert().matchesAccount(cm, account); 
        } 

    } 

    public static AccountSelection and(AccountSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndAccountSelection(selections); 
        } 
    } 

    public static AccountSelection and(Selector.AccountSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), AccountSelection[]::new)); 
    } 

    public static AccountSelection or(AccountSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrAccountSelection(selections); 
        } 
    } 

    public static AccountSelection or(Selector.AccountSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), AccountSelection[]::new)); 
    } 

    public static AccountSelection not(Selector.AccountSelector selector) 
    { 
        return new NotAccountSelection(selector.getSelection()); 
    } 

    public static class AndBookSelection 
        extends AbstractAndSelection<BookSelection> 
        implements AbstractBookSelection 
    { 
        public AndBookSelection(BookSelection... selections) 
        { 
        } 

        public boolean matchesBook(final CollectionManager cm, final BookKey book) 
        { 
            final List<BookSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesBook(cm, book)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrBookSelection 
        extends AbstractOrSelection<BookSelection> 
        implements AbstractBookSelection 
    { 
        public OrBookSelection(BookSelection... selections) 
        { 
        } 

        public boolean matchesBook(CollectionManager cm, final BookKey book) 
        { 
            final List<BookSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesBook(cm, book)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotBookSelection 
        extends AbstractNotSelection<BookSelection> 
        implements AbstractBookSelection 
    { 
        public NotBookSelection(BookSelection selection) 
        { 
        } 

        public boolean matchesBook(CollectionManager cm, final BookKey book) 
        { 
            return !getSelectionToInvert().matchesBook(cm, book); 
        } 

    } 

    public static BookSelection and(BookSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndBookSelection(selections); 
        } 
    } 

    public static BookSelection and(Selector.BookSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), BookSelection[]::new)); 
    } 

    public static BookSelection or(BookSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrBookSelection(selections); 
        } 
    } 

    public static BookSelection or(Selector.BookSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), BookSelection[]::new)); 
    } 

    public static BookSelection not(Selector.BookSelector selector) 
    { 
        return new NotBookSelection(selector.getSelection()); 
    } 

    public static class AndEntityLegSelection 
        extends AbstractAndSelection<EntityLegSelection> 
        implements AbstractEntityLegSelection 
    { 
        public AndEntityLegSelection(EntityLegSelection... selections) 
        { 
        } 

        public boolean matchesEntityLeg(final CollectionManager cm, final EntityKey entity, final int leg) 
        { 
            final List<EntityLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesEntityLeg(cm, entity, leg)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrEntityLegSelection 
        extends AbstractOrSelection<EntityLegSelection> 
        implements AbstractEntityLegSelection 
    { 
        public OrEntityLegSelection(EntityLegSelection... selections) 
        { 
        } 

        public boolean matchesEntityLeg(CollectionManager cm, final EntityKey entity, final int leg) 
        { 
            final List<EntityLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesEntityLeg(cm, entity, leg)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotEntityLegSelection 
        extends AbstractNotSelection<EntityLegSelection> 
        implements AbstractEntityLegSelection 
    { 
        public NotEntityLegSelection(EntityLegSelection selection) 
        { 
        } 

        public boolean matchesEntityLeg(CollectionManager cm, final EntityKey entity, final int leg) 
        { 
            return !getSelectionToInvert().matchesEntityLeg(cm, entity, leg); 
        } 

    } 

    public static EntityLegSelection and(EntityLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndEntityLegSelection(selections); 
        } 
    } 

    public static EntityLegSelection and(Selector.EntityLegSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), EntityLegSelection[]::new)); 
    } 

    public static EntityLegSelection or(EntityLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrEntityLegSelection(selections); 
        } 
    } 

    public static EntityLegSelection or(Selector.EntityLegSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), EntityLegSelection[]::new)); 
    } 

    public static EntityLegSelection not(Selector.EntityLegSelector selector) 
    { 
        return new NotEntityLegSelection(selector.getSelection()); 
    } 

    public static class AndEntitySelection 
        extends AbstractAndSelection<EntitySelection> 
        implements AbstractEntitySelection 
    { 
        public AndEntitySelection(EntitySelection... selections) 
        { 
        } 

        public boolean matchesEntity(final CollectionManager cm, final EntityKey entity) 
        { 
            final List<EntitySelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesEntity(cm, entity)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrEntitySelection 
        extends AbstractOrSelection<EntitySelection> 
        implements AbstractEntitySelection 
    { 
        public OrEntitySelection(EntitySelection... selections) 
        { 
        } 

        public boolean matchesEntity(CollectionManager cm, final EntityKey entity) 
        { 
            final List<EntitySelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesEntity(cm, entity)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotEntitySelection 
        extends AbstractNotSelection<EntitySelection> 
        implements AbstractEntitySelection 
    { 
        public NotEntitySelection(EntitySelection selection) 
        { 
        } 

        public boolean matchesEntity(CollectionManager cm, final EntityKey entity) 
        { 
            return !getSelectionToInvert().matchesEntity(cm, entity); 
        } 

    } 

    public static EntitySelection and(EntitySelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndEntitySelection(selections); 
        } 
    } 

    public static EntitySelection and(Selector.EntitySelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), EntitySelection[]::new)); 
    } 

    public static EntitySelection or(EntitySelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrEntitySelection(selections); 
        } 
    } 

    public static EntitySelection or(Selector.EntitySelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), EntitySelection[]::new)); 
    } 

    public static EntitySelection not(Selector.EntitySelector selector) 
    { 
        return new NotEntitySelection(selector.getSelection()); 
    } 

    public static class AndEntityGangSelection 
        extends AbstractAndSelection<EntityGangSelection> 
        implements AbstractEntityGangSelection 
    { 
        public AndEntityGangSelection(EntityGangSelection... selections) 
        { 
        } 

        public boolean matchesEntityGang(final CollectionManager cm, final EntityKey entity, final BrokerKey gang) 
        { 
            final List<EntityGangSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesEntityGang(cm, entity, gang)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrEntityGangSelection 
        extends AbstractOrSelection<EntityGangSelection> 
        implements AbstractEntityGangSelection 
    { 
        public OrEntityGangSelection(EntityGangSelection... selections) 
        { 
        } 

        public boolean matchesEntityGang(CollectionManager cm, final EntityKey entity, final BrokerKey gang) 
        { 
            final List<EntityGangSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesEntityGang(cm, entity, gang)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotEntityGangSelection 
        extends AbstractNotSelection<EntityGangSelection> 
        implements AbstractEntityGangSelection 
    { 
        public NotEntityGangSelection(EntityGangSelection selection) 
        { 
        } 

        public boolean matchesEntityGang(CollectionManager cm, final EntityKey entity, final BrokerKey gang) 
        { 
            return !getSelectionToInvert().matchesEntityGang(cm, entity, gang); 
        } 

    } 

    public static EntityGangSelection and(EntityGangSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndEntityGangSelection(selections); 
        } 
    } 

    public static EntityGangSelection and(Selector.EntityGangSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), EntityGangSelection[]::new)); 
    } 

    public static EntityGangSelection or(EntityGangSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrEntityGangSelection(selections); 
        } 
    } 

    public static EntityGangSelection or(Selector.EntityGangSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), EntityGangSelection[]::new)); 
    } 

    public static EntityGangSelection not(Selector.EntityGangSelector selector) 
    { 
        return new NotEntityGangSelection(selector.getSelection()); 
    } 

    public static class AndFactionAccountSelection 
        extends AbstractAndSelection<FactionAccountSelection> 
        implements AbstractFactionAccountSelection 
    { 
        public AndFactionAccountSelection(FactionAccountSelection... selections) 
        { 
        } 

        public boolean matchesFactionAccount(final CollectionManager cm, final FactionKey faction, final AccountKey account) 
        { 
            final List<FactionAccountSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesFactionAccount(cm, faction, account)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrFactionAccountSelection 
        extends AbstractOrSelection<FactionAccountSelection> 
        implements AbstractFactionAccountSelection 
    { 
        public OrFactionAccountSelection(FactionAccountSelection... selections) 
        { 
        } 

        public boolean matchesFactionAccount(CollectionManager cm, final FactionKey faction, final AccountKey account) 
        { 
            final List<FactionAccountSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesFactionAccount(cm, faction, account)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotFactionAccountSelection 
        extends AbstractNotSelection<FactionAccountSelection> 
        implements AbstractFactionAccountSelection 
    { 
        public NotFactionAccountSelection(FactionAccountSelection selection) 
        { 
        } 

        public boolean matchesFactionAccount(CollectionManager cm, final FactionKey faction, final AccountKey account) 
        { 
            return !getSelectionToInvert().matchesFactionAccount(cm, faction, account); 
        } 

    } 

    public static FactionAccountSelection and(FactionAccountSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndFactionAccountSelection(selections); 
        } 
    } 

    public static FactionAccountSelection and(Selector.FactionAccountSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), FactionAccountSelection[]::new)); 
    } 

    public static FactionAccountSelection or(FactionAccountSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrFactionAccountSelection(selections); 
        } 
    } 

    public static FactionAccountSelection or(Selector.FactionAccountSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), FactionAccountSelection[]::new)); 
    } 

    public static FactionAccountSelection not(Selector.FactionAccountSelector selector) 
    { 
        return new NotFactionAccountSelection(selector.getSelection()); 
    } 

    public static class AndFactionLegSelection 
        extends AbstractAndSelection<FactionLegSelection> 
        implements AbstractFactionLegSelection 
    { 
        public AndFactionLegSelection(FactionLegSelection... selections) 
        { 
        } 

        public boolean matchesFactionLeg(final CollectionManager cm, final FactionKey faction, final int leg) 
        { 
            final List<FactionLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesFactionLeg(cm, faction, leg)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrFactionLegSelection 
        extends AbstractOrSelection<FactionLegSelection> 
        implements AbstractFactionLegSelection 
    { 
        public OrFactionLegSelection(FactionLegSelection... selections) 
        { 
        } 

        public boolean matchesFactionLeg(CollectionManager cm, final FactionKey faction, final int leg) 
        { 
            final List<FactionLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesFactionLeg(cm, faction, leg)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotFactionLegSelection 
        extends AbstractNotSelection<FactionLegSelection> 
        implements AbstractFactionLegSelection 
    { 
        public NotFactionLegSelection(FactionLegSelection selection) 
        { 
        } 

        public boolean matchesFactionLeg(CollectionManager cm, final FactionKey faction, final int leg) 
        { 
            return !getSelectionToInvert().matchesFactionLeg(cm, faction, leg); 
        } 

    } 

    public static FactionLegSelection and(FactionLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndFactionLegSelection(selections); 
        } 
    } 

    public static FactionLegSelection and(Selector.FactionLegSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), FactionLegSelection[]::new)); 
    } 

    public static FactionLegSelection or(FactionLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrFactionLegSelection(selections); 
        } 
    } 

    public static FactionLegSelection or(Selector.FactionLegSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), FactionLegSelection[]::new)); 
    } 

    public static FactionLegSelection not(Selector.FactionLegSelector selector) 
    { 
        return new NotFactionLegSelection(selector.getSelection()); 
    } 

    public static class AndFactionSelection 
        extends AbstractAndSelection<FactionSelection> 
        implements AbstractFactionSelection 
    { 
        public AndFactionSelection(FactionSelection... selections) 
        { 
        } 

        public boolean matchesFaction(final CollectionManager cm, final FactionKey faction) 
        { 
            final List<FactionSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesFaction(cm, faction)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrFactionSelection 
        extends AbstractOrSelection<FactionSelection> 
        implements AbstractFactionSelection 
    { 
        public OrFactionSelection(FactionSelection... selections) 
        { 
        } 

        public boolean matchesFaction(CollectionManager cm, final FactionKey faction) 
        { 
            final List<FactionSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesFaction(cm, faction)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotFactionSelection 
        extends AbstractNotSelection<FactionSelection> 
        implements AbstractFactionSelection 
    { 
        public NotFactionSelection(FactionSelection selection) 
        { 
        } 

        public boolean matchesFaction(CollectionManager cm, final FactionKey faction) 
        { 
            return !getSelectionToInvert().matchesFaction(cm, faction); 
        } 

    } 

    public static FactionSelection and(FactionSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndFactionSelection(selections); 
        } 
    } 

    public static FactionSelection and(Selector.FactionSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), FactionSelection[]::new)); 
    } 

    public static FactionSelection or(FactionSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrFactionSelection(selections); 
        } 
    } 

    public static FactionSelection or(Selector.FactionSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), FactionSelection[]::new)); 
    } 

    public static FactionSelection not(Selector.FactionSelector selector) 
    { 
        return new NotFactionSelection(selector.getSelection()); 
    } 

    public static class AndLegSelection 
        extends AbstractAndSelection<LegSelection> 
        implements AbstractLegSelection 
    { 
        public AndLegSelection(LegSelection... selections) 
        { 
        } 

        public boolean matchesLeg(final CollectionManager cm, final int leg) 
        { 
            final List<LegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesLeg(cm, leg)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrLegSelection 
        extends AbstractOrSelection<LegSelection> 
        implements AbstractLegSelection 
    { 
        public OrLegSelection(LegSelection... selections) 
        { 
        } 

        public boolean matchesLeg(CollectionManager cm, final int leg) 
        { 
            final List<LegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesLeg(cm, leg)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotLegSelection 
        extends AbstractNotSelection<LegSelection> 
        implements AbstractLegSelection 
    { 
        public NotLegSelection(LegSelection selection) 
        { 
        } 

        public boolean matchesLeg(CollectionManager cm, final int leg) 
        { 
            return !getSelectionToInvert().matchesLeg(cm, leg); 
        } 

    } 

    public static LegSelection and(LegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndLegSelection(selections); 
        } 
    } 

    public static LegSelection and(Selector.LegSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), LegSelection[]::new)); 
    } 

    public static LegSelection or(LegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrLegSelection(selections); 
        } 
    } 

    public static LegSelection or(Selector.LegSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), LegSelection[]::new)); 
    } 

    public static LegSelection not(Selector.LegSelector selector) 
    { 
        return new NotLegSelection(selector.getSelection()); 
    } 

    public static class AndFruitLegAppleSauceSelection 
        extends AbstractAndSelection<FruitLegAppleSauceSelection> 
        implements AbstractFruitLegAppleSauceSelection 
    { 
        public AndFruitLegAppleSauceSelection(FruitLegAppleSauceSelection... selections) 
        { 
        } 

        public boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit positionQuark, final int leg, final InstrumentKey appleSauce) 
        { 
            final List<FruitLegAppleSauceSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesFruitLegAppleSauce(cm, positionQuark, leg, appleSauce)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrFruitLegAppleSauceSelection 
        extends AbstractOrSelection<FruitLegAppleSauceSelection> 
        implements AbstractFruitLegAppleSauceSelection 
    { 
        public OrFruitLegAppleSauceSelection(FruitLegAppleSauceSelection... selections) 
        { 
        } 

        public boolean matchesFruitLegAppleSauce(CollectionManager cm, final Fruit positionQuark, final int leg, final InstrumentKey appleSauce) 
        { 
            final List<FruitLegAppleSauceSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesFruitLegAppleSauce(cm, positionQuark, leg, appleSauce)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotFruitLegAppleSauceSelection 
        extends AbstractNotSelection<FruitLegAppleSauceSelection> 
        implements AbstractFruitLegAppleSauceSelection 
    { 
        public NotFruitLegAppleSauceSelection(FruitLegAppleSauceSelection selection) 
        { 
        } 

        public boolean matchesFruitLegAppleSauce(CollectionManager cm, final Fruit positionQuark, final int leg, final InstrumentKey appleSauce) 
        { 
            return !getSelectionToInvert().matchesFruitLegAppleSauce(cm, positionQuark, leg, appleSauce); 
        } 

    } 

    public static FruitLegAppleSauceSelection and(FruitLegAppleSauceSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndFruitLegAppleSauceSelection(selections); 
        } 
    } 

    public static FruitLegAppleSauceSelection and(Selector.FruitLegAppleSauceSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), FruitLegAppleSauceSelection[]::new)); 
    } 

    public static FruitLegAppleSauceSelection or(FruitLegAppleSauceSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrFruitLegAppleSauceSelection(selections); 
        } 
    } 

    public static FruitLegAppleSauceSelection or(Selector.FruitLegAppleSauceSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), FruitLegAppleSauceSelection[]::new)); 
    } 

    public static FruitLegAppleSauceSelection not(Selector.FruitLegAppleSauceSelector selector) 
    { 
        return new NotFruitLegAppleSauceSelection(selector.getSelection()); 
    } 

    public static class AndFruitLegSelection 
        extends AbstractAndSelection<FruitLegSelection> 
        implements AbstractFruitLegSelection 
    { 
        public AndFruitLegSelection(FruitLegSelection... selections) 
        { 
        } 

        public boolean matchesFruitLeg(final CollectionManager cm, final Fruit positionQuark, final int leg) 
        { 
            final List<FruitLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesFruitLeg(cm, positionQuark, leg)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrFruitLegSelection 
        extends AbstractOrSelection<FruitLegSelection> 
        implements AbstractFruitLegSelection 
    { 
        public OrFruitLegSelection(FruitLegSelection... selections) 
        { 
        } 

        public boolean matchesFruitLeg(CollectionManager cm, final Fruit positionQuark, final int leg) 
        { 
            final List<FruitLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesFruitLeg(cm, positionQuark, leg)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotFruitLegSelection 
        extends AbstractNotSelection<FruitLegSelection> 
        implements AbstractFruitLegSelection 
    { 
        public NotFruitLegSelection(FruitLegSelection selection) 
        { 
        } 

        public boolean matchesFruitLeg(CollectionManager cm, final Fruit positionQuark, final int leg) 
        { 
            return !getSelectionToInvert().matchesFruitLeg(cm, positionQuark, leg); 
        } 

    } 

    public static FruitLegSelection and(FruitLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndFruitLegSelection(selections); 
        } 
    } 

    public static FruitLegSelection and(Selector.FruitLegSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), FruitLegSelection[]::new)); 
    } 

    public static FruitLegSelection or(FruitLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrFruitLegSelection(selections); 
        } 
    } 

    public static FruitLegSelection or(Selector.FruitLegSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), FruitLegSelection[]::new)); 
    } 

    public static FruitLegSelection not(Selector.FruitLegSelector selector) 
    { 
        return new NotFruitLegSelection(selector.getSelection()); 
    } 

    public static class AndFruitSelection 
        extends AbstractAndSelection<FruitSelection> 
        implements AbstractFruitSelection 
    { 
        public AndFruitSelection(FruitSelection... selections) 
        { 
        } 

        public boolean matchesFruit(final CollectionManager cm, final Fruit positionQuark) 
        { 
            final List<FruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesFruit(cm, positionQuark)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

        public boolean isRestrictsToBundle() 
        { 
            final List<FruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).isRestrictsToBundle()) { 
                    return true; 
                } 
            } 

            return false; 
        } 
        public boolean isRestrictsToBusinessUnit() 
        { 
            final List<FruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).isRestrictsToBusinessUnit()) { 
                    return true; 
                } 
            } 

            return false; 
        } 
    } 

    public static class OrFruitSelection 
        extends AbstractOrSelection<FruitSelection> 
        implements AbstractFruitSelection 
    { 
        public OrFruitSelection(FruitSelection... selections) 
        { 
        } 

        public boolean matchesFruit(CollectionManager cm, final Fruit positionQuark) 
        { 
            final List<FruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesFruit(cm, positionQuark)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

        public boolean isRestrictsToBundle() 
        { 
            final List<FruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).isRestrictsToBundle()) { 
                    return true; 
                } 
            } 

            return false; 
        } 
        public boolean isRestrictsToBusinessUnit() 
        { 
            final List<FruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).isRestrictsToBusinessUnit()) { 
                    return true; 
                } 
            } 

            return false; 
        } 
    } 

    public static class NotFruitSelection 
        extends AbstractNotSelection<FruitSelection> 
        implements AbstractFruitSelection 
    { 
        public NotFruitSelection(FruitSelection selection) 
        { 
        } 

        public boolean matchesFruit(CollectionManager cm, final Fruit positionQuark) 
        { 
            return !getSelectionToInvert().matchesFruit(cm, positionQuark); 
        } 

        public boolean isRestrictsToBundle() 
        { 
            return getSelectionToInvert().isRestrictsToBundle(); 
        } 
        public boolean isRestrictsToBusinessUnit() 
        { 
            return getSelectionToInvert().isRestrictsToBusinessUnit(); 
        } 
    } 

    public static FruitSelection and(FruitSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndFruitSelection(selections); 
        } 
    } 

    public static FruitSelection and(Selector.FruitSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), FruitSelection[]::new)); 
    } 

    public static FruitSelection or(FruitSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrFruitSelection(selections); 
        } 
    } 

    public static FruitSelection or(Selector.FruitSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), FruitSelection[]::new)); 
    } 

    public static FruitSelection not(Selector.FruitSelector selector) 
    { 
        return new NotFruitSelection(selector.getSelection()); 
    } 

    public static class AndGangSelection 
        extends AbstractAndSelection<GangSelection> 
        implements AbstractGangSelection 
    { 
        public AndGangSelection(GangSelection... selections) 
        { 
        } 

        public boolean matchesGang(final CollectionManager cm, final BrokerKey gang) 
        { 
            final List<GangSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesGang(cm, gang)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrGangSelection 
        extends AbstractOrSelection<GangSelection> 
        implements AbstractGangSelection 
    { 
        public OrGangSelection(GangSelection... selections) 
        { 
        } 

        public boolean matchesGang(CollectionManager cm, final BrokerKey gang) 
        { 
            final List<GangSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesGang(cm, gang)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotGangSelection 
        extends AbstractNotSelection<GangSelection> 
        implements AbstractGangSelection 
    { 
        public NotGangSelection(GangSelection selection) 
        { 
        } 

        public boolean matchesGang(CollectionManager cm, final BrokerKey gang) 
        { 
            return !getSelectionToInvert().matchesGang(cm, gang); 
        } 

    } 

    public static GangSelection and(GangSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndGangSelection(selections); 
        } 
    } 

    public static GangSelection and(Selector.GangSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), GangSelection[]::new)); 
    } 

    public static GangSelection or(GangSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrGangSelection(selections); 
        } 
    } 

    public static GangSelection or(Selector.GangSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), GangSelection[]::new)); 
    } 

    public static GangSelection not(Selector.GangSelector selector) 
    { 
        return new NotGangSelection(selector.getSelection()); 
    } 

    public static class AndQuarterFruitLegSelection 
        extends AbstractAndSelection<QuarterFruitLegSelection> 
        implements AbstractQuarterFruitLegSelection 
    { 
        public AndQuarterFruitLegSelection(QuarterFruitLegSelection... selections) 
        { 
        } 

        public boolean matchesQuarterFruitLeg(final CollectionManager cm, final int quarter, final Fruit positionQuark, final int leg) 
        { 
            final List<QuarterFruitLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesQuarterFruitLeg(cm, quarter, positionQuark, leg)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrQuarterFruitLegSelection 
        extends AbstractOrSelection<QuarterFruitLegSelection> 
        implements AbstractQuarterFruitLegSelection 
    { 
        public OrQuarterFruitLegSelection(QuarterFruitLegSelection... selections) 
        { 
        } 

        public boolean matchesQuarterFruitLeg(CollectionManager cm, final int quarter, final Fruit positionQuark, final int leg) 
        { 
            final List<QuarterFruitLegSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesQuarterFruitLeg(cm, quarter, positionQuark, leg)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotQuarterFruitLegSelection 
        extends AbstractNotSelection<QuarterFruitLegSelection> 
        implements AbstractQuarterFruitLegSelection 
    { 
        public NotQuarterFruitLegSelection(QuarterFruitLegSelection selection) 
        { 
        } 

        public boolean matchesQuarterFruitLeg(CollectionManager cm, final int quarter, final Fruit positionQuark, final int leg) 
        { 
            return !getSelectionToInvert().matchesQuarterFruitLeg(cm, quarter, positionQuark, leg); 
        } 

    } 

    public static QuarterFruitLegSelection and(QuarterFruitLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndQuarterFruitLegSelection(selections); 
        } 
    } 

    public static QuarterFruitLegSelection and(Selector.QuarterFruitLegSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), QuarterFruitLegSelection[]::new)); 
    } 

    public static QuarterFruitLegSelection or(QuarterFruitLegSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrQuarterFruitLegSelection(selections); 
        } 
    } 

    public static QuarterFruitLegSelection or(Selector.QuarterFruitLegSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), QuarterFruitLegSelection[]::new)); 
    } 

    public static QuarterFruitLegSelection not(Selector.QuarterFruitLegSelector selector) 
    { 
        return new NotQuarterFruitLegSelection(selector.getSelection()); 
    } 

    public static class AndQuarterFruitSelection 
        extends AbstractAndSelection<QuarterFruitSelection> 
        implements AbstractQuarterFruitSelection 
    { 
        public AndQuarterFruitSelection(QuarterFruitSelection... selections) 
        { 
        } 

        public boolean matchesQuarterFruit(final CollectionManager cm, final int quarter, final Fruit positionQuark) 
        { 
            final List<QuarterFruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesQuarterFruit(cm, quarter, positionQuark)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrQuarterFruitSelection 
        extends AbstractOrSelection<QuarterFruitSelection> 
        implements AbstractQuarterFruitSelection 
    { 
        public OrQuarterFruitSelection(QuarterFruitSelection... selections) 
        { 
        } 

        public boolean matchesQuarterFruit(CollectionManager cm, final int quarter, final Fruit positionQuark) 
        { 
            final List<QuarterFruitSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesQuarterFruit(cm, quarter, positionQuark)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotQuarterFruitSelection 
        extends AbstractNotSelection<QuarterFruitSelection> 
        implements AbstractQuarterFruitSelection 
    { 
        public NotQuarterFruitSelection(QuarterFruitSelection selection) 
        { 
        } 

        public boolean matchesQuarterFruit(CollectionManager cm, final int quarter, final Fruit positionQuark) 
        { 
            return !getSelectionToInvert().matchesQuarterFruit(cm, quarter, positionQuark); 
        } 

    } 

    public static QuarterFruitSelection and(QuarterFruitSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndQuarterFruitSelection(selections); 
        } 
    } 

    public static QuarterFruitSelection and(Selector.QuarterFruitSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), QuarterFruitSelection[]::new)); 
    } 

    public static QuarterFruitSelection or(QuarterFruitSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrQuarterFruitSelection(selections); 
        } 
    } 

    public static QuarterFruitSelection or(Selector.QuarterFruitSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), QuarterFruitSelection[]::new)); 
    } 

    public static QuarterFruitSelection not(Selector.QuarterFruitSelector selector) 
    { 
        return new NotQuarterFruitSelection(selector.getSelection()); 
    } 

    public static class AndQuarterGangSelection 
        extends AbstractAndSelection<QuarterGangSelection> 
        implements AbstractQuarterGangSelection 
    { 
        public AndQuarterGangSelection(QuarterGangSelection... selections) 
        { 
        } 

        public boolean matchesQuarterGang(final CollectionManager cm, final int quarter, final BrokerKey gang) 
        { 
            final List<QuarterGangSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (!selections.get(i).matchesQuarterGang(cm, quarter, gang)) { 
                    return false; 
                } 
            } 
            return true; 
        } 

    } 

    public static class OrQuarterGangSelection 
        extends AbstractOrSelection<QuarterGangSelection> 
        implements AbstractQuarterGangSelection 
    { 
        public OrQuarterGangSelection(QuarterGangSelection... selections) 
        { 
        } 

        public boolean matchesQuarterGang(CollectionManager cm, final int quarter, final BrokerKey gang) 
        { 
            final List<QuarterGangSelection> selections = getSelections(); 
            for (int i = 0; i < selections.size(); i++) { 
                if (selections.get(i).matchesQuarterGang(cm, quarter, gang)) { 
                    return true; 
                } 
            } 
            return false; 
        } 

    } 

    public static class NotQuarterGangSelection 
        extends AbstractNotSelection<QuarterGangSelection> 
        implements AbstractQuarterGangSelection 
    { 
        public NotQuarterGangSelection(QuarterGangSelection selection) 
        { 
        } 

        public boolean matchesQuarterGang(CollectionManager cm, final int quarter, final BrokerKey gang) 
        { 
            return !getSelectionToInvert().matchesQuarterGang(cm, quarter, gang); 
        } 

    } 

    public static QuarterGangSelection and(QuarterGangSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new AndQuarterGangSelection(selections); 
        } 
    } 

    public static QuarterGangSelection and(Selector.QuarterGangSelector... selectors) 
    { 
        return and(ArrayUtil.map(selectors, s -> s.getSelection(), QuarterGangSelection[]::new)); 
    } 

    public static QuarterGangSelection or(QuarterGangSelection... selections) 
    { 
        if (selections.length == 0) { 
            return NoneSelection.NONE; 
        } 
        else if (selections.length == 1) { 
            return selections[0]; 
        } 
        else { 
            return new OrQuarterGangSelection(selections); 
        } 
    } 

    public static QuarterGangSelection or(Selector.QuarterGangSelector... selectors) 
    { 
        return or(ArrayUtil.map(selectors, s -> s.getSelection(), QuarterGangSelection[]::new)); 
    } 

    public static QuarterGangSelection not(Selector.QuarterGangSelector selector) 
    { 
        return new NotQuarterGangSelection(selector.getSelection()); 
    } 

    public interface AbstractAccountLegSelection 
        extends AccountLegSelection 
    { 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesAccountLeg(cm, aFruit.getAccountKey(), aLeg); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesAccountLeg(cm, aFruit.getAccountKey(), aLeg); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesAccountLeg(cm, aFruit.getAccountKey(), aLeg); 
        } 
    } 

    public interface AbstractAccountSelection 
        extends AccountSelection 
    { 
        public default boolean matchesAccountLeg(final CollectionManager cm, final AccountKey aAccount, final int aLeg) 
        { 
            return matchesAccount(cm, aAccount); 
        } 
        public default boolean matchesFactionAccount(final CollectionManager cm, final FactionKey aFaction, final AccountKey aAccount) 
        { 
            return matchesAccount(cm, aAccount); 
        } 
        public default boolean matchesFruit(final CollectionManager cm, final Fruit aFruit) 
        { 
            return matchesAccount(cm, aFruit.getAccountKey()); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesAccount(cm, aFruit.getAccountKey()); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesAccount(cm, aFruit.getAccountKey()); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesAccount(cm, aFruit.getAccountKey()); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesAccount(cm, aFruit.getAccountKey()); 
        } 
    } 

    public interface AbstractBookSelection 
        extends BookSelection 
    { 
        public default boolean matchesFruit(final CollectionManager cm, final Fruit aFruit) 
        { 
            return matchesBook( 
                cm, 
                null 
            ); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesBook( 
                cm, 
                null 
            ); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesBook( 
                cm, 
                null 
            ); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesBook( 
                cm, 
                null 
            ); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesBook( 
                cm, 
                null 
            ); 
        } 
    } 

    public interface AbstractEntityLegSelection 
        extends EntityLegSelection 
    { 
        public default boolean matchesAccountLeg(final CollectionManager cm, final AccountKey aAccount, final int aLeg) 
        { 
            return matchesEntityLeg(cm, null, aLeg); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesEntityLeg(cm, null, aLeg); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesEntityLeg(cm, null, aLeg); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesEntityLeg(cm, null, aLeg); 
        } 
    } 

    public interface AbstractEntitySelection 
        extends EntitySelection 
    { 
        public default boolean matchesEntityLeg(final CollectionManager cm, final EntityKey aEntity, final int aLeg) 
        { 
            return matchesEntity(cm, aEntity); 
        } 
        public default boolean matchesAccount(final CollectionManager cm, final AccountKey aAccount) 
        { 
            return matchesEntity(cm, null); 
        } 
        public default boolean matchesAccountLeg(final CollectionManager cm, final AccountKey aAccount, final int aLeg) 
        { 
            return matchesEntity(cm, null); 
        } 
        public default boolean matchesEntityGang(final CollectionManager cm, final EntityKey aEntity, final BrokerKey aGang) 
        { 
            return matchesEntity(cm, aEntity); 
        } 
        public default boolean matchesFactionAccount(final CollectionManager cm, final FactionKey aFaction, final AccountKey aAccount) 
        { 
            return matchesEntity(cm, null); 
        } 
        public default boolean matchesFruit(final CollectionManager cm, final Fruit aFruit) 
        { 
            return matchesEntity(cm, null); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesEntity(cm, null); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesEntity(cm, null); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesEntity(cm, null); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesEntity(cm, null); 
        } 
    } 

    public interface AbstractEntityGangSelection 
        extends EntityGangSelection 
    { 
        public default boolean matchesAccount(CollectionManager cm, 
                                              AccountKey aAccount) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
        public default boolean matchesAccountLeg(CollectionManager cm, 
                                                 AccountKey aAccount, int aLeg) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
        public default boolean matchesFactionAccount(final CollectionManager cm, final FactionKey aFaction, final AccountKey aAccount) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
        public default boolean matchesFruit(final CollectionManager cm, final Fruit aFruit) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesEntityGang(cm, null, null); 
        } 
    } 

    public interface AbstractFactionAccountSelection 
        extends FactionAccountSelection 
    { 
        public default boolean matchesFruit(final CollectionManager cm, final Fruit aFruit) 
        { 
            return matchesFactionAccount(cm, aFruit.getFactionKey(), aFruit.getAccountKey()); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFactionAccount(cm, aFruit.getFactionKey(), aFruit.getAccountKey()); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesFactionAccount(cm, aFruit.getFactionKey(), aFruit.getAccountKey()); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesFactionAccount(cm, aFruit.getFactionKey(), aFruit.getAccountKey()); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFactionAccount(cm, aFruit.getFactionKey(), aFruit.getAccountKey()); 
        } 
    } 

    public interface AbstractFactionLegSelection 
        extends FactionLegSelection 
    { 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFactionLeg(cm, aFruit.getFactionKey(), aLeg); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesFactionLeg(cm, aFruit.getFactionKey(), aLeg); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFactionLeg(cm, aFruit.getFactionKey(), aLeg); 
        } 
    } 

    public interface AbstractFactionSelection 
        extends FactionSelection 
    { 
        public default boolean matchesFactionAccount(final CollectionManager cm, final FactionKey aFaction, final AccountKey aAccount) 
        { 
            return matchesFaction(cm, aFaction); 
        } 
        public default boolean matchesFactionLeg(final CollectionManager cm, final FactionKey aFaction, final int aLeg) 
        { 
            return matchesFaction(cm, aFaction); 
        } 
        public default boolean matchesFruit(final CollectionManager cm, final Fruit aFruit) 
        { 
            return matchesFaction(cm, aFruit.getFactionKey()); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFaction(cm, aFruit.getFactionKey()); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesFaction(cm, aFruit.getFactionKey()); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesFaction(cm, aFruit.getFactionKey()); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFaction(cm, aFruit.getFactionKey()); 
        } 
    } 

    public interface AbstractLegSelection 
        extends LegSelection 
    { 
        public default boolean matchesAccountLeg(final CollectionManager cm, final AccountKey aAccount, final int aLeg) 
        { 
            return matchesLeg(cm, aLeg); 
        } 
        public default boolean matchesEntityLeg(final CollectionManager cm, final EntityKey aEntity, final int aLeg) 
        { 
            return matchesLeg(cm, aLeg); 
        } 
        public default boolean matchesFactionLeg(final CollectionManager cm, final FactionKey aFaction, final int aLeg) 
        { 
            return matchesLeg(cm, aLeg); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesLeg(cm, aLeg); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesLeg(cm, aLeg); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesLeg(cm, aLeg); 
        } 
    } 

    public interface AbstractFruitLegAppleSauceSelection 
        extends FruitLegAppleSauceSelection 
    { 
    } 

    public interface AbstractFruitLegSelection 
        extends FruitLegSelection 
    { 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesFruitLeg(cm, aFruit, aLeg); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFruitLeg(cm, aFruit, aLeg); 
        } 
    } 

    public interface AbstractFruitSelection 
        extends FruitSelection 
    { 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFruit(cm, aFruit); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesFruit(cm, aFruit); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesFruit(cm, aFruit); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesFruit(cm, aFruit); 
        } 
    } 

    public interface AbstractGangSelection 
        extends GangSelection 
    { 
        public default boolean matchesAccount(final CollectionManager cm, final AccountKey aAccount) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesAccountLeg(final CollectionManager cm, final AccountKey aAccount, final int aLeg) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesEntityGang(final CollectionManager cm, final EntityKey aEntity, final BrokerKey aGang) 
        { 
            return matchesGang(cm, aGang); 
        } 
        public default boolean matchesFactionAccount(final CollectionManager cm, final FactionKey aFaction, final AccountKey aAccount) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesFruit(final CollectionManager cm, final Fruit aFruit) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesFruitLeg(final CollectionManager cm, final Fruit aFruit, final int aLeg) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesFruitLegAppleSauce(final CollectionManager cm, final Fruit aFruit, final int aLeg, final InstrumentKey aAppleSauce) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesGang(cm, null); 
        } 
        public default boolean matchesQuarterGang(final CollectionManager cm, final int aQuarter, final BrokerKey aGang) 
        { 
            return matchesGang(cm, aGang); 
        } 
    } 

    public interface AbstractQuarterFruitLegSelection 
        extends QuarterFruitLegSelection 
    { 
    } 

    public interface AbstractQuarterFruitSelection 
        extends QuarterFruitSelection 
    { 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesQuarterFruit(cm, aQuarter, aFruit); 
        } 
    } 

    public interface AbstractQuarterGangSelection 
        extends QuarterGangSelection 
    { 
        public default boolean matchesQuarterFruit(final CollectionManager cm, final int aQuarter, final Fruit aFruit) 
        { 
            return matchesQuarterGang(cm, aQuarter, null); 
        } 
        public default boolean matchesQuarterFruitLeg(final CollectionManager cm, final int aQuarter, final Fruit aFruit, final int aLeg) 
        { 
            return matchesQuarterGang(cm, aQuarter, null); 
        } 
    } 
} 


class NoneSelection 
    extends AbstractSelection 
    implements Selection.AccountLegSelection, 
               Selection.BookSelection, 
               Selection.EntityLegSelection, 
               Selection.EntityGangSelection, 
               Selection.EntitySelection, 
               Selection.FactionAccountSelection, 
               Selection.FactionLegSelection, 
               Selection.FactionSelection, 
               Selection.LegSelection, 
               Selection.FruitLegAppleSauceSelection, 
               Selection.FruitLegSelection, 
               Selection.FruitSelection, 
               Selection.GangSelection, 
               Selection.QuarterFruitLegSelection, 
               Selection.QuarterFruitSelection, 
               Selection.QuarterGangSelection 
{ 
    public static final NoneSelection NONE = new NoneSelection(); 

    public NoneSelection getSelection() 
    { 
        return null; 
    } 

    public boolean matchesAccountLeg(CollectionManager cm, final AccountKey account, final int leg) { return false; } 
    public boolean matchesAccount(CollectionManager cm, final AccountKey account) { return false; } 
    public boolean matchesBook(CollectionManager cm, final BookKey book) { return false; } 
    public boolean matchesEntityLeg(CollectionManager cm, final EntityKey entity, final int leg) { return false; } 
    public boolean matchesEntity(CollectionManager cm, final EntityKey entity) { return false; } 
    public boolean matchesEntityGang(CollectionManager cm, final EntityKey entity, final BrokerKey gang) { return false; } 
    public boolean matchesFactionAccount(CollectionManager cm, final FactionKey faction, final AccountKey account) { return false; } 
    public boolean matchesFactionLeg(CollectionManager cm, final FactionKey faction, final int leg) { return false; } 
    public boolean matchesFaction(CollectionManager cm, final FactionKey faction) { return false; } 
    public boolean matchesLeg(CollectionManager cm, final int leg) { return false; } 
    public boolean matchesFruitLegAppleSauce(CollectionManager cm, final Fruit positionQuark, final int leg, final InstrumentKey appleSauce) { return false; } 
    public boolean matchesFruitLeg(CollectionManager cm, final Fruit positionQuark, final int leg) { return false; } 
    public boolean matchesFruit(CollectionManager cm, final Fruit positionQuark) { return false; } 
    public boolean matchesGang(CollectionManager cm, final BrokerKey gang) { return false; } 
    public boolean matchesQuarterFruitLeg(CollectionManager cm, final int quarter, final Fruit positionQuark, final int leg) { return false; } 
    public boolean matchesQuarterFruit(CollectionManager cm, final int quarter, final Fruit positionQuark) { return false; } 
    public boolean matchesQuarterGang(CollectionManager cm, final int quarter, final BrokerKey gang) { return false; } 
}