--- Web/FileSystem Crawler ---
Start Time: /*pmb.webFsCrawlStartTime:orElse('-')*/
End Time:   /*pmb.webFsCrawlEndTime:orElse('-')*/
Exec Time:  /*pmb.webFsCrawlExecTime:orElse('-')*/ ms

--- Web/FileSystem Indexer ---
Exec Time:  /*pmb.webFsIndexExecTime:orElse('-')*/ ms
Num of Doc: /*pmb.webFsIndexSize:orElse('-')*/ docs

--- Data Store Crawler ---
Start Time: /*pmb.dataCrawlStartTime:orElse('-')*/

    other.use {
      other.start(addressA, 0)

      // Same address is okay.
      other.start(addressA, 0)

      // Same address with bound port is okay.
      other.start(addressA, other.port)

      // Different address is not okay.
      assertFailsWith<IllegalStateException> {
        other.start(addressB, 0)
      }

      // Different port is not okay.

        final int start = dstIndex;
        dstIndex += calledName.writeWireFormat(dst, dstIndex);
        dstIndex += callingName.writeWireFormat(dst, dstIndex);
        return dstIndex - start;
    }

    @Override
    int readTrailerWireFormat(final InputStream in, final byte[] buffer, int bufferIndex) throws IOException {
        final int start = bufferIndex;

    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        int start = dstIndex;

        // Write context header
        SMBUtil.writeInt4(0, dst, dstIndex); // Next (offset to next context, 0 for last)
        dstIndex += 4;

        SMBUtil.writeInt2(16, dst, dstIndex); // NameOffset (from start of context)
        dstIndex += 2;

        SMBUtil.writeInt2(4, dst, dstIndex); // NameLength

            dstIndex += this.salt.length;
        }

        return dstIndex - start;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int nalgos = SMBUtil.readInt2(buffer, bufferIndex);

            pb.redirectErrorStream(true);
        };

        try {
            // Start first process
            JobProcess jobProcess1 = processHelper.startProcess(sessionId, cmdList1, pbCall);
            assertNotNull(jobProcess1);
            assertTrue(processHelper.isProcessRunning(sessionId));

            // Start second process with same session ID (should replace first)

    ByteString state = randomToken();
    synchronized (this) {
      listeners.put(state, listener);
    }

    return slackApi.authorizeUrl(scopes, redirectUrl(), state, team);
  }

  private ByteString randomToken() {
    byte[] bytes = new byte[16];
    secureRandom.nextBytes(bytes);
    return ByteString.of(bytes);
  }

  private HttpUrl redirectUrl() {

    checkNotClosed();
    target.append(charSeq);
    return this;
  }

  @Override
  public Writer append(@Nullable CharSequence charSeq, int start, int end) throws IOException {
    checkNotClosed();
    target.append(charSeq, start, end);
    return this;
  }

  private void checkNotClosed() throws IOException {
    if (closed) {
      throw new IOException("Cannot write to a closed writer.");

        // However, we'll try to read it safely for compatibility
        if (this.byteCount > bufferIndex - start) {
            try {
                // Attempt to read nativeFileSystem, but don't fail if there are issues
                final int fsLen = this.byteCount - (bufferIndex - start);
                if (fsLen > 0 && fsLen < 256) { // Sanity check on length

     *
     * @param value the content to append
     * @param start the starting index of the subsequence to be appended
     * @param end the end index of the subsequence to be appended
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder a(CharSequence value, int start, int end) {
        return append(value, start, end);
    }

    /**
     * Append content to the message buffer.