super(delegate);
  }

  @Override
  protected SortedMultiset<E> delegate() {
    return (SortedMultiset<E>) super.delegate();
  }

  @Override
  public Comparator<? super E> comparator() {
    return delegate().comparator();
  }

  @Override
  NavigableSet<E> createElementSet() {
    return unmodifiableNavigableSet(delegate().elementSet());
  }

  @Override
  public NavigableSet<E> elementSet() {

      this.backingQueue = backingQueue;
    }

    @Override
    protected Queue<T> delegate() {
      return backingQueue;
    }

    @Override
    public boolean addAll(Collection<? extends T> collection) {
      return standardAddAll(collection);
    }

    @Override
    public void clear() {
      standardClear();
    }

    @Override
    public boolean contains(Object object) {

    }
  }

  @Override
  public @Nullable Entry<E> firstEntry() {
    return delegate().firstEntry();
  }

  /**
   * A sensible definition of {@link #firstEntry()} in terms of {@code entrySet().iterator()}.
   *
   * <p>If you override {@link #entrySet()}, you may wish to override {@link #firstEntry()} to
   * forward to this implementation.
   */

    @Override
    public Object getImmediateNode() {
        return attrib;
    }

    @Override
    public int getLength() {
        return 1;
    }

    @Override
    public QName getName() {
        return new QName(null, attrib.getKey());
    }

    @Override
    public boolean isActual() {
        return true;
    }

    @Override
    public boolean isCollection() {
        return false;
    }

    this.pattern = Preconditions.checkNotNull(pattern);
  }

  @Override
  public CommonMatcher matcher(CharSequence t) {
    return new JdkMatcher(pattern.matcher(t));
  }

  @Override
  public String pattern() {
    return pattern.pattern();
  }

  @Override
  public int flags() {
    return pattern.flags();
  }

  @Override
  public String toString() {
    return pattern.toString();
  }

public interface ByteArrayDataOutput extends DataOutput {
  @Override
  void write(int b);

  @Override
  void write(byte[] b);

  @Override
  void write(byte[] b, int off, int len);

  @Override
  void writeBoolean(boolean v);

  @Override
  void writeByte(int v);

  @Override
  void writeShort(int v);

  @Override
  void writeChar(int v);

  @Override
  void writeInt(int v);

  @Override

        }

        @Override
        public int size() {
            return parent.size();
        }

        @Override
        public boolean isEmpty() {
            return parent.isEmpty();
        }

        @Override
        public boolean contains(final Object o) {
            return parent.contains(o);
        }

        @Override
        public Iterator<E> iterator() {

      throw new AssertionError();
    }

    @Override
    public DummyInternalEntry getNext() {
      throw new AssertionError();
    }

    @Override
    public int getHash() {
      throw new AssertionError();
    }

    @Override
    public Object getKey() {
      throw new AssertionError();
    }

    @Override
    public Object getValue() {

      object : Call {
        override fun request(): Request = TODO()

        override fun execute(): Response = TODO()

        override fun enqueue(responseCallback: Callback) = TODO()

        override fun cancel() = TODO()

        override fun isExecuted(): Boolean = TODO()

        override fun isCanceled(): Boolean = TODO()

        override fun timeout(): Timeout = TODO()

    }

    @Override
    String getKeyRole() {
      return "Column";
    }

    @Override
    Map<R, @Nullable V> getValue(int index) {
      return new Column(index);
    }

    @Override
    Map<R, @Nullable V> setValue(int index, Map<R, @Nullable V> newValue) {
      throw new UnsupportedOperationException();
    }

    @Override