}
    Map<C, Map<R, V>> columns = Maps.newLinkedHashMap();
    for (C col : columnSpace) {
      columns.put(col, new LinkedHashMap<R, V>());
    }
    int[] cellRowIndices = new int[cellList.size()];
    int[] cellColumnInRowIndices = new int[cellList.size()];
    for (int i = 0; i < cellList.size(); i++) {
      Cell<R, C, V> cell = cellList.get(i);
      R rowKey = cell.getRowKey();
      C columnKey = cell.getColumnKey();

     */

    public static final int ERROR_SUCCESS = 0;
    public static final int ERROR_ACCESS_DENIED = 5;
    public static final int ERROR_REQ_NOT_ACCEP = 71;
    public static final int ERROR_BAD_PIPE = 230;
    public static final int ERROR_PIPE_BUSY = 231;
    public static final int ERROR_NO_DATA = 232;
    public static final int ERROR_PIPE_NOT_CONNECTED = 233;
    public static final int ERROR_MORE_DATA = 234;

 *
 */
public class FileNotifyInformationImpl implements FileNotifyInformation, Decodable {

    int nextEntryOffset;
    int action;
    int fileNameLength;
    String fileName;


    /**
     * 
     */
    public FileNotifyInformationImpl () {}


    @Override
    public int getAction () {
        return this.action;
    }


    @Override
    public String getFileName () {

   */
  internal class ContinuationSource(
    private val source: BufferedSource,
  ) : Source {
    var length: Int = 0
    var flags: Int = 0
    var streamId: Int = 0

    var left: Int = 0
    var padding: Int = 0

    @Throws(IOException::class)
    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      while (left == 0) {

    private int getLeftChildIndex(int i) {
      return i * 2 + 1;
    }

    private int getRightChildIndex(int i) {
      return i * 2 + 2;
    }

    private int getParentIndex(int i) {
      return (i - 1) / 2;
    }

    private int getGrandparentIndex(int i) {
      return getParentIndex(getParentIndex(i)); // (i - 3) / 4
    }
  }

public class Referral implements Decodable {

    int version;
    int size;
    int serverType;
    int rflags;
    int proximity;
    String altPath;

    int ttl;
    String rpath = null;
    String node = null;
    String specialName = null;

    String[] expandedNames = new String[0];


    /**
     * @return the version
     */
    public final int getVersion () {
        return this.version;
    }

        final int size = docs.size();
        if (size == 0) {
            return docs; // empty
        }
        int fromIndex = startPosition;
        if (fromIndex >= size) {
            fromIndex = size - 1;
        }
        int toIndex = startPosition + pageSize;
        if (toIndex >= size) {

public class InternersBenchmark {
  @Benchmark
  int weakInterner(int reps) {
    Interner<String> interner = Interners.newWeakInterner();
    for (int i = 0; i < reps; i++) {
      String unused = interner.intern(Double.toHexString(Math.random()));
    }
    return reps;
  }

  @Benchmark
  int strongInterner(int reps) {
    Interner<String> interner = Interners.newStrongInterner();
    for (int i = 0; i < reps; i++) {

    }

    // Turn an 8-byte key into internal keys.
    private void deskey( byte[] keyBlock, boolean encrypting, int[] KnL ) {

        int i, j, l, m, n;
        int[] pc1m = new int[56];
        int[] pcr  = new int[56];
        int[] kn   = new int[32];

        for ( j = 0; j < 56; ++j )  {
            l       = pc1[j];
            m       = l & 07;

        return dstIndex - start;
    }
    int writeDataWireFormat( byte[] dst, int dstIndex ) {
        return 0;
    }
    int readSetupWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }
    int readParametersWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }
    int readDataWireFormat( byte[] buffer, int bufferIndex, int len ) {
        return 0;
    }