import java.util.*;

/* Questa soluzione usa TreeSet, alternativamente si poteva usare List e 
 * mantenere esplicitamente l'ordinamento lessicografico. */
public class SeqSet<V extends Comparable<? super V>> implements Iterable<Seq<V>> {
    private static class SeqComparator<V extends Comparable<? super V>> implements Comparator<Seq<V>> {
        public int compare(Seq<V> s1, Seq<V> s2) {
            if (s1 == null || s2 == null) 
                throw new NullPointerException();
            int n1 = s1.length(), n2 = s2.length();
            int i = 0;
            while (i < n1 && i < n2 && s1.get(i).equals(s2.get(i)))
                i++;
            if (i < n1 && i < n2)
                return s1.get(i).compareTo(s2.get(i));
            else if (i < n1) return 1;
            else if (i < n2) return -1;
            else return 0;
        }
    }
    
    private final SeqComparator<V> comparator = new SeqComparator<V>();
    private NavigableSet<Seq<V>> set = new TreeSet<Seq<V>>(comparator);
    
    public SeqSet() {}
    
    public SeqSet(Collection<? extends Seq<V>> coll) {
        set.addAll(coll);    //Se coll è null, lancia NullPointerException
    }
    
    public boolean add(Seq<V> s) {
        return set.add(s);         //Se s è null, lancia NullPointerException
    }
    
    public boolean contains(Seq<V> s) {
        return set.contains(s);    //Se s è null, lancia NullPointerException
    }
    
    public boolean remove(Seq<V> s) {
        return set.remove(s);      //Se s è null, lancia NullPointerException
    }
    
    public Seq<V> ceiling(Seq<V> s) {
        return set.ceiling(s);     //Se s è null, lancia NullPointerException
    }

    public Iterator<Seq<V>> iterator() {
        return set.iterator();    //Itera seguendo l'ordine lessicografico ascendente
    }
}

import java.util.*;

public class SubSeqSet<V extends Comparable<? super V>> extends SeqSet<V> {
    private Seq<V> base;
    
    public SubSeqSet(Seq<V> b) {
        super();
        base = b;
    }
    
    public SubSeqSet(Seq<V> b, Collection<? extends Seq<V>> coll) {
        this(b);
        for (Seq<V> s : coll)
            add(s);
    }
    
        //Metodo ausiliario che ritorna true se s è una sottosequenza di base
    private boolean issubseq(Seq<V> s) {
        int k = 0, i = 0;
        while (i < s.length() && k < base.length()) {
            while (k < base.length() && !base.get(k).equals(s.get(i)))
                k++;
            if (k == base.length()) return false;
            i++;
            k++;
        }
        return true;
    }
    
    @Override
    public boolean add(Seq<V> s) {
        if (s == null)
            throw new NullPointerException();
        if (!issubseq(s)) 
            return false;
        return super.add(s);
    }
    
    public Map<V, Integer> count() {
        Map<V, Integer> map = new HashMap<V, Integer>();
        for (int i = 0 ; i < base.length() ; i++)
            map.put(base.get(i), 0);
        for (Seq<V> s : this) {
            Set<V> valset = new HashSet<V>();
            for (int i = 0 ; i < s.length() ; i++)
                valset.add(s.get(i));
            for (V v : valset)
                map.put(v, map.get(v) + 1);
        }
        return map;
    }
}