@Override
              protected Set<String> create(String[] elements) {
                String[] deduped = dedupe(elements);
                return new AbstractSet<String>() {
                  @Override
                  public int size() {
                    return deduped.length;
                  }

                  @Override
                  public Iterator<String> iterator() {

  }

  @Override
  public SampleElements<String> sampleValues() {
    return new SampleElements<>("January", "February", "March", "April", "May");
  }

  @Override
  public Collection<String> createCollection(Iterable<? extends String> values) {
    return copyToList(values);
  }

  @Override
  public final ListMultimap<String, String> create(Object... entries) {

  /** Constructor for use by subclasses. */
  protected ForwardingBlockingQueue() {}

  @Override
  protected abstract BlockingQueue<E> delegate();

  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c, int maxElements) {
    return delegate().drainTo(c, maxElements);
  }

  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c) {
    return delegate().drainTo(c);
  }

        }
        this.handshakeComplete = true;
    }

    @Override
    public URL getURL() {
        return this.connection.getURL();
    }

    @Override
    public int getContentLength() {
        handshake();
        return this.connection.getContentLength();
    }

    @Override
    public String getContentType() {
        handshake();

  }

  @Override
  public void write(byte[] b, int off, int len) throws IOException {
    // Override slow FilterOutputStream impl
    out.write(b, off, len);
  }

  @Override
  public void writeBoolean(boolean v) throws IOException {
    ((DataOutputStream) out).writeBoolean(v);
  }

  @Override
  public void writeByte(int v) throws IOException {

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(Class<T> type) {
    return trustedGet(TypeToken.of(type));
  }

  @Override
  public <T extends @NonNull B> @Nullable T getInstance(TypeToken<T> type) {
    return trustedGet(type.rejectTypeVariables());
  }

  @Override
  @CanIgnoreReturnValue
  public <T extends B> @Nullable T putInstance(

    }

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

    @Override
    public void setBlacklisted(boolean blackListed) {
        // no op
    }

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

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

    @Override

      @Override
      protected Entry<Class<? extends @NonNull B>, B> delegate() {
        return entry;
      }

      @Override
      @ParametricNullness
      public B setValue(@ParametricNullness B value) {
        cast(getKey(), value);
        return super.setValue(value);
      }
    };
  }

  @Override

        }
    }

    @Override
    public BeanDesc getBeanDesc() {
        return beanDesc;
    }

    @SuppressWarnings("unchecked")
    @Override
    public <T> Constructor<T> getConstructor() {
        return (Constructor<T>) constructor;
    }

    @Override
    public Class<?>[] getParameterTypes() {
        return parameterTypes;
    }

    @Override
    public boolean isPublic() {

    }

    @Override
    int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeParametersWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeDataWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override