'%'.code,
          '\\'.code,
          '^'.code,
          '`'.code,
          '{'.code,
          '|'.code,
          '}'.code,
        )

    Component.FRAGMENT ->
      UrlComponentEncodingTesterJvmPlatform()
        .escapeForUri(
          '%'.code,
          ' '.code,
          '"'.code,
          '#'.code,
          '<'.code,
          '>'.code,
          '\\'.code,

     */
    @Override
    public int size () {
        return 8;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode ( byte[] dst, int dstIndex ) {
        SMBUtil.writeInt8(this.indexNumber, dst, dstIndex);
        return 8;
    }


    @Override
    public String toString () {

  private const val INITIAL_BIAS = 72
  private const val INITIAL_N = 0x80

  /**
   * Returns null if any label is oversized so much that the encoder cannot encode it without
   * integer overflow. This will not return null for labels that fit within the DNS size
   * limits.
   */
  fun encode(string: String): String? {
    var pos = 0
    val limit = string.length
    val result = Buffer()

    while (pos < limit) {

     */
    @Override
    public int size () {
        return 8;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode ( byte[] dst, int dstIndex ) {
        SMBUtil.writeInt8(this.endOfFile, dst, dstIndex);
        return 8;
    }


    /**
     * {@inheritDoc}
     *

	enc := json.NewEncoder(os.Stdout)
	if err = enc.Encode(&start); err != nil {
		log.Fatalln(err)
	}

	fmt.Println()
	for {
		_, status, err := madmClnt.Heal(context.Background(), "healing-rewrite-bucket", "", opts, start.ClientToken, false, false)
		if status.Summary == "finished" {
			fmt.Println("Healstatus on items ===")
			for _, item := range status.Items {
				if err = enc.Encode(&item); err != nil {
					log.Fatalln(err)
				}

 * limitations under the License.
 */
package okhttp3.internal.http2

import assertk.assertThat
import assertk.assertions.isEqualTo
import java.util.Random
import okhttp3.internal.http2.Huffman.decode
import okhttp3.internal.http2.Huffman.encode
import okhttp3.internal.http2.Huffman.encodedLength
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.encodeUtf8
import okio.ByteString.Companion.toByteString

	}{Version: healthInfo.Version}

	enc := json.NewEncoder(gzWriter)
	if e := enc.Encode(header); e != nil {
		internalLogIf(ctx, fmt.Errorf("Could not encode health info header: %w", e))
		return nil
	}

	if e := enc.Encode(healthInfo); e != nil {
		internalLogIf(ctx, fmt.Errorf("Could not encode health info: %w", e))
		return nil
	}

	gzWriter.Flush()
	gzWriter.Close()

     */
    @Override
    public int getContextType () {
        return NEGO_CTX_ENC_TYPE;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        SMBUtil.writeInt2(this.ciphers != null ? this.ciphers.length : 0, dst, dstIndex);
        dstIndex += 2;

            _src.advance(1 * _nodes);

            if ( this.node == null ) {
                if ( _nodes < 0 || _nodes > 0xFFFF )
                    throw new NdrException(NdrException.INVALID_CONFORMANCE);
                this.node = new byte[_nodes];
            }
            _src = _src.derive(_nodei);
            for ( int _i = 0; _i < _nodes; _i++ ) {
                this.node[ _i ] = (byte) _src.dec_ndr_small();
            }
        }

     */
    @Override
    public int size () {
        return 22;
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.Encodable#encode(byte[], int)
     */
    @Override
    public int encode ( byte[] dst, int dstIndex ) {
        int start = dstIndex;
        SMBUtil.writeInt8(this.allocationSize, dst, dstIndex);
        dstIndex += 8;