checkNotNull(columnFunction, "columnFunction");
    checkNotNull(valueFunction, "valueFunction");
    checkNotNull(mergeFunction, "mergeFunction");

    /*
     * No mutable Table exactly matches the insertion order behavior of ImmutableTable.Builder, but
     * the Builder can't efficiently support merging of duplicate values.  Getting around this
     * requires some work.
     */

    return Collector.of(

    }

    @Test
    void testToStringWithOptions() throws DcerpcException {
        dcerpcBinding.setOption("connect", "80");
        dcerpcBinding.setOption("bind", "123");
        // Order of options in toString might vary due to HashMap, so check for containment
        String result = dcerpcBinding.toString();
        assertTrue(result.startsWith(PROTO + ":" + SERVER + "[null,"), "toString should start correctly.");

     *
     * @param functions A collection of functions, each taking a String as input and returning a String.
     * @return A function that applies each function in the collection in order until a non-null result is found.
     *         If all functions return null, the composite function returns null.
     *
     * @throws NullPointerException if the input collection is null or contains null elements.
     */

 * collector by only using a constant number of internal objects.
 *
 * <p>If there are no removals, then iteration order for the {@link #entrySet}, {@link #keySet}, and
 * {@link #values} views is the same as insertion order. Any removal invalidates any ordering
 * guarantees.
 *
 * <p>This class should not be assumed to be universally superior to {@code java.util.HashMap}.

   * PermittedMetaException}.
   */
  protected final class MultiExceptionListIterator implements ListIterator<E> {
    // TODO: track seen elements when order isn't guaranteed
    // TODO: verify contents afterward
    // TODO: something shiny and new instead of Stack
    // TODO: test whether null is supported (create a Feature)
    /**

            return getHostAddress();
        }
        return hostName.name;
    }

    /**
     * Returns the raw IP address of this NbtAddress. The result is in network
     * byte order: the highest order byte of the address is in getAddress()[0].
     *
     * @return a four byte array
     */

    public byte[] getAddress() {
        final byte[] addr = new byte[4];

                                </div>
                                <div class="row">
                                    <div class="col-sm-12">
                                        <table class="table table-bordered table-striped">
                                            <thead>
                                            <tr>
                                                <th><la:message key="labels.backup_name"/></th>

  }

  open fun trustManager(sslSocketFactory: SSLSocketFactory): X509TrustManager? {
    return try {
      // Attempt to get the trust manager from an OpenJDK socket factory. We attempt this on all
      // platforms in order to support Robolectric, which mixes classes from both Android and the
      // Oracle JDK. Note that we don't support HTTP/2 or other nice features on Robolectric.

import importlib
import inspect as _inspect
import os as _os
import site as _site
import sys as _sys
import sysconfig

# pylint: disable=g-bad-import-order,protected-access,g-import-not-at-top
from tensorflow.python import pywrap_tensorflow  # pylint: disable=unused-import
from tensorflow.python.tools import module_util as _module_util

        }
      }
      mappings.put(var, arg);
    }
  }

  // This is needed when resolving types against a context with wildcards
  // For example:
  // class Holder<T> {
  //   void set(T data) {...}
  // }
  // Holder<List<?>> should *not* resolve the set() method to set(List<?> data).
  // Instead, it should create a capture of the wildcard so that set() rejects any List<T>.