/* RPC major / minor version */
        if (buf.dec_ndr_small() != 5 || buf.dec_ndr_small() != 0)
            throw new NdrException("DCERPC version not supported");
        ptype = buf.dec_ndr_small();
        flags = buf.dec_ndr_small();
        if (buf.dec_ndr_long() != 0x00000010) /* Little-endian / ASCII / IEEE */
            throw new NdrException("Data representation not supported");
        length = buf.dec_ndr_short();

    registry.register(o1);

    Iterator<Subscriber> three = registry.getSubscribers("");
    assertEquals(s1, one.next().target);
    assertFalse(one.hasNext());

    assertEquals(s1, three.next().target);
    assertEquals(s2, three.next().target);
    assertEquals(o1, three.next().target);
    assertFalse(three.hasNext());

    three = registry.getSubscribers("");

    registry.unregister(s2);

                            break;
                        default:
                            throw new SmbException( "Invalid operation for " + service + " service" );
                    }
                    break;
                default:
                    throw new SmbException( "Invalid operation for " + service + " service" + request );
            }
        }
        request.tid = tid;

    public void formatProgress(StringBuilder builder, long progressedSize, long size) {
        if (progressedSize < 0L) {
            throw new IllegalArgumentException("progressed file size cannot be negative: " + size);
        }
        if (size >= 0 && progressedSize > size) {
            throw new IllegalArgumentException(
                    "progressed file size cannot be greater than size: " + progressedSize + " > " + size);
        }

        val request = Request.Builder()
            .url("https://publicobject.com/helloworld.txt")
            .build()

        client.newCall(request).execute().use { response ->
          if (!response.isSuccessful) throw IOException("Unexpected code $response")

          for ((name, value) in response.headers) {
            println("$name: $value")
          }

          println(response.body!!.string())
        }
      }

        fromSink.emit()
      }
      else -> throw ProtocolException("unsupported method: $selectedMethod")
    }
  }

  private fun acceptCommand(
    fromAddress: InetAddress,
    fromSource: BufferedSource,
    fromSink: BufferedSink,
  ) {
    // Read the command.
    val version = fromSource.readByte() and 0xff
    if (version != VERSION_5) throw ProtocolException("unexpected version: $version")

        String p = loc.getURL().getPath();
        if ( p.lastIndexOf('/') != ( p.length() - 1 ) ) {
            throw new SmbException(loc.getURL() + " directory must end with '/'");
        }
        if ( unc.lastIndexOf('\\') != ( unc.length() - 1 ) ) {
            throw new SmbException(unc + " UNC must end with '\\'");
        }

        SmbTreeHandleImpl th = getTreeHandle();

                int errorCode = (int)( in.read() & 0xFF );
                close();
                throw new NbtException( NbtException.ERR_SSN_SRVC, errorCode );
            case -1:
                throw new NbtException( NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED );
            default:
                close();
                throw new NbtException( NbtException.ERR_SSN_SRVC, 0 );
        }
    }

  public boolean addAll(Collection<? extends E> elementsToAdd) {
    throw up();
  }

  @Override
  public boolean removeAll(Collection<?> elementsToRemove) {
    throw up();
  }

  @Override
  public boolean retainAll(Collection<?> elementsToRetain) {
    throw up();
  }

  @Override
  public void clear() {
    throw up();
  }

  private static UnsupportedOperationException up() {

  override val routePlanner: RoutePlanner,
) : ExchangeFinder {
  override fun find(): RealConnection {
    var firstException: IOException? = null
    while (true) {
      if (routePlanner.isCanceled()) throw IOException("Canceled")

      try {
        val plan = routePlanner.plan()

        if (!plan.isReady) {
          val tcpConnectResult = plan.connectTcp()
          val connectResult =
            when {