return Signature.getInstance(tbsCertificate.signatureAlgorithmName).run {
      initVerify(issuer)
      update(signedData.toByteArray())
      verify(signatureValue.byteString.toByteArray())
    }
  }

  fun toX509Certificate(): X509Certificate {
    val data = CertificateAdapters.certificate.toDer(this)
    try {

      length: Int,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_DATA
      this.inFinished = inFinished
      this.streamId = streamId
      this.data = source.readByteString(length.toLong()).toByteArray()
    }

    override fun rstStream(
      streamId: Int,
      errorCode: ErrorCode,
    ) {
      check(type == -1)
      this.type = Http2.TYPE_RST_STREAM
      this.streamId = streamId

    try {
      ObjectOutputStream out = new ObjectOutputStream(bytes);
      out.writeObject(object);
      ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes.toByteArray()));
      return (T) requireNonNull(in.readObject());
    } catch (IOException | ClassNotFoundException e) {
      throw new RuntimeException(e);
    }
  }

  private Platform() {}

     * @param mechanism the mechanism OID to set
     */
    public void setMechanism(final ASN1ObjectIdentifier mechanism) {
        this.mechanism = mechanism;
    }

    @Override
    public byte[] toByteArray() {
        try {
            final ByteArrayOutputStream collector = new ByteArrayOutputStream();
            final ASN1OutputStream der = ASN1OutputStream.create(collector, ASN1Encoding.DER);

        }
        throw new ClassCastException();
    }

    /**
     * Gets the byte array representation of this SID.
     *
     * @return encoded SID
     */
    public byte[] toByteArray() {
        return toByteArray(this);
    }

    /**
     * Checks whether the SID is empty (no sub-authorities).
     *
     * @return whether the SID is empty (no sub-authorities)
     */

        switch (state) {
        case 1:
            final Type1Message msg1 = new Type1Message(ntlmsspFlags, auth.getDomain(), workstation);
            token = msg1.toByteArray();

            if (LogStream.level >= 4) {
                log.println(msg1);
                if (LogStream.level >= 6) {
                    Hexdump.hexdump(log, token, 0, token.length);
                }

        .build(),
    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    connection.doOutput = true
    connection.getOutputStream().write("ABCDEF".toByteArray(UTF_8))
    val inputStream = connection.getInputStream()
    assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos

        final Type1Message type1Message = new Type1Message(cifsContext, TYPE_1_FLAGS, domain, workstation);
        return Base64.getEncoder().encodeToString(type1Message.toByteArray());
    }

    /**
     * Generates a Type 3 NTLM message.
     *
     * @param username the username
     * @param password the password
     * @param domain the domain

    BloomFilter<byte[]> bf = BloomFilter.create(Funnels.byteArrayFunnel(), 100);
    for (int i = 0; i < 10; i++) {
      bf.put(Ints.toByteArray(i));
    }

    BloomFilter<byte[]> copy = SerializableTester.reserialize(bf);
    for (int i = 0; i < 10; i++) {
      assertTrue(copy.mightContain(Ints.toByteArray(i)));
    }
    assertThat(copy.expectedFpp()).isEqualTo(bf.expectedFpp());

    SerializableTester.reserializeAndAssert(bf);

        }
        return String.format("NegTokenInit[flags=%d,mechs=%s,mic=%s]", this.getContextFlags(), Arrays.toString(this.getMechanisms()), mic);
    }

    @Override
    public byte[] toByteArray() {
        try {
            final ASN1EncodableVector fields = new ASN1EncodableVector();
            final ASN1ObjectIdentifier[] mechs = getMechanisms();
            if (mechs != null) {