CompactLinkedHashMap(int expectedSize, boolean accessOrder) {
    super(expectedSize);
    this.accessOrder = accessOrder;
  }

  @Override
  void init(int expectedSize) {
    super.init(expectedSize);
    this.firstEntry = ENDPOINT;
    this.lastEntry = ENDPOINT;
  }

  @Override
  int allocArrays() {
    int expectedSize = super.allocArrays();
    this.links = new long[expectedSize];

    private long offset;

private int pad;

    int writeMode;

    SmbComWriteAndX() {
        super( null );
        command = SMB_COM_WRITE_ANDX;
    }
    SmbComWriteAndX( int fid, long offset, int remaining,
                    byte[] b, int off, int len, ServerMessageBlock andx ) {
        super( andx );
        this.fid = fid;
        this.offset = offset;
        this.remaining = remaining;
        this.b = b;

    private static final long serialVersionUID = 1L;

    public SuggesterException(final String msg) {
        super(msg);
    }

    public SuggesterException(final Throwable cause) {
        super(cause);
    }

    public SuggesterException(final String msg, final Throwable cause) {
        super(msg, cause);
    }

  final Predicate<? super Entry<K, V>> predicate;

  FilteredEntryMultimap(Multimap<K, V> unfiltered, Predicate<? super Entry<K, V>> predicate) {
    this.unfiltered = checkNotNull(unfiltered);
    this.predicate = checkNotNull(predicate);
  }

  @Override
  public Multimap<K, V> unfiltered() {
    return unfiltered;
  }

  @Override
  public Predicate<? super Entry<K, V>> entryPredicate() {

      super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(
        String message, String a1, String a2, String a3) {
      super(message);
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(String message, Throwable antecedent) {
      super(message);
      this.antecedent = antecedent;
    }

    public ExceptionWithManyConstructorsButOnlyOneThrowable(

  private final transient Comparator<? super K> comparator;

  ImmutableSortedMap(SortedMap<K, V> delegate, Comparator<? super K> comparator) {
    super(delegate);
    this.comparator = comparator;
    this.sortedDelegate = delegate;
  }

  public static <T extends @Nullable Object, K, V>
      Collector<T, ?, ImmutableSortedMap<K, V>> toImmutableSortedMap(
          Comparator<? super K> comparator,

            MessageBuilderFactory messageBuilderFactory, PrintWriter out, boolean printResourceNames) {
        super(messageBuilderFactory, out);
        this.printResourceNames = printResourceNames;
    }

    @Override
    public void transferInitiated(TransferEvent event) {
        overridePreviousTransfer(event);

        super.transferInitiated(event);
    }

    @Override

    public GraphConflictResolutionException(String message) {
        super(message);
    }

    public GraphConflictResolutionException(Throwable cause) {
        super(cause);
    }

    public GraphConflictResolutionException(String message, Throwable cause) {
        super(message, cause);
    }

     * @param cause The cause, may be {@code null}.
     */
    public UnresolvableModelException(
            String message, String groupId, String artifactId, String version, Throwable cause) {
        super(message, cause);
        this.groupId = (groupId != null) ? groupId : "";
        this.artifactId = (artifactId != null) ? artifactId : "";
        this.version = (version != null) ? version : "";
    }

    /**

@ElementTypesAreNonnullByDefault
public class TreeBasedTable<R, C, V> extends StandardRowSortedTable<R, C, V> {
  private final Comparator<? super C> columnComparator;

  private static class Factory<C, V> implements Supplier<Map<C, V>>, Serializable {
    final Comparator<? super C> comparator;

    Factory(Comparator<? super C> comparator) {
      this.comparator = comparator;
    }

    @Override
    public Map<C, V> get() {