}
        return null;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Address#unwrap(java.lang.Class)
     */
    @SuppressWarnings("unchecked")
    @Override
    public <T extends Address> T unwrap(final Class<T> type) {
        if (this.addr instanceof Address) {
            return ((Address) this.addr).unwrap(type);
        }

     */
    public static <T> T[] add(final T[] array, final T obj) {
        assertArgumentNotNull("array", array);

        final int length = array.length;
        @SuppressWarnings("unchecked")
        final T[] newArray = (T[]) Array.newInstance(array.getClass().getComponentType(), length + 1);
        System.arraycopy(array, 0, newArray, 0, length);
        newArray[length] = obj;
        return newArray;

  }

  /**
   * Returns the empty immutable multiset.
   *
   * <p><b>Performance note:</b> the instance returned is a singleton.
   */
  @SuppressWarnings("unchecked") // all supported methods are covariant
  public static <E> ImmutableMultiset<E> of() {
    return (ImmutableMultiset<E>) RegularImmutableMultiset.EMPTY;
  }

  /**

  public <N1 extends N, E1 extends E> MutableNetwork<N1, E1> build() {
    return new StandardMutableNetwork<>(this);
  }

  @SuppressWarnings("unchecked")
  private <N1 extends N, E1 extends E> NetworkBuilder<N1, E1> cast() {
    return (NetworkBuilder<N1, E1>) this;
  }

   */
  @GwtIncompatible // java.io.ObjectInputStream
  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();
    @SuppressWarnings("unchecked") // reading data stored by writeObject
    Class<E> localType = (Class<E>) requireNonNull(stream.readObject());
    type = localType;
    enumConstants = type.getEnumConstants();
    counts = new int[enumConstants.length];

    stream.writeObject(keyComparator());
    stream.writeObject(valueComparator());
    Serialization.writeMultimap(this, stream);
  }

  @GwtIncompatible
  @J2ktIncompatible
    @SuppressWarnings("unchecked") // reading data stored by writeObject
  private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
    stream.defaultReadObject();

        return delegate.getInflightRequests();
    }

    @Override
    public CIFSContext getContext() {
        return delegate.getContext();
    }

    @Override
    @SuppressWarnings("unchecked")
    public <T extends SmbTransport> T unwrap(Class<T> type) {
        if (type.isAssignableFrom(this.getClass())) {
            return (T) this;
        }
        return delegate.unwrap(type);
    }

      implements Collection<E> {
    private SynchronizedCollection(Collection<E> delegate, @Nullable Object mutex) {
      super(delegate, mutex);
    }

    @SuppressWarnings("unchecked")
    @Override
    Collection<E> delegate() {
      return (Collection<E>) super.delegate();
    }

    @Override
    public boolean add(E e) {
      synchronized (mutex) {

   * unchecked cast at some later point:
   *
   * {@snippet :
   * @SuppressWarnings("unchecked") // safe because of ::isInstance check
   * ImmutableList<NewType> result =
   *     (ImmutableList) stream.filter(NewType.class::isInstance).collect(toImmutableList());
   * }
   */
  @SuppressWarnings("unchecked")
  @GwtIncompatible // Class.isInstance

                    safeParamMap.keySet(), e);
            logScriptExecution(template, "failure:" + e.getClass().getSimpleName());
            return null;
        }
    }

    @SuppressWarnings("unchecked")
    private CachedScript getOrCompile(final String template) {
        try {
            return scriptCache.get(template, () -> {