public abstract class ByteSink {

  /** Constructor for use by subclasses. */
  protected ByteSink() {}

  /**
   * Returns a {@link CharSink} view of this {@code ByteSink} that writes characters to this sink as
   * bytes encoded with the given {@link Charset charset}.
   */
  public CharSink asCharSink(Charset charset) {
    return new AsCharSink(charset);
  }

  /**

// The value returned is the logical OR of multiple possible formats.
// If the value is FormatUnknown, then the input Header cannot be encoded
// and an error is returned explaining why.
//
// As a by-product of checking the fields, this function returns paxHdrs, which
// contain all fields that could not be directly encoded.
// A value receiver ensures that this method does not mutate the source Header.

}

// parseNumeric parses the input as being encoded in either base-256 or octal.
// This function may return negative numbers.
// If parsing fails or an integer overflow occurs, err will be set.
func (p *parser) parseNumeric(b []byte) int64 {
	// Check for base-256 (binary) format first.
	// If the first bit is set, then all following bits constitute a two's
	// complement encoded number in big-endian byte order.

                .build(),
            ).post(query.toRequestBody(DNS_MESSAGE))
        } else {
          val encoded = query.base64Url().replace("=", "")
          val requestUrl = dnsUrl.newBuilder().addQueryParameter("dns", encoded).build()

          url(requestUrl)
        }
      }.build()

  class Builder {
    internal var client: OkHttpClient? = null

        url = "file:/" + encodeUrl("ホーム") + "/user";
        exp = "localhost";
        assertEquals(exp, transformer.getHostOnFile(url));

        url = "file:/c:/" + encodeUrl("ホーム") + "/user";
        exp = "localhost";
        assertEquals(exp, transformer.getHostOnFile(url));

        url = "file:////" + encodeUrl("サーバー") + "/home/user";
        exp = "サーバー";

import java.net.ProtocolException
import okio.Buffer
import okio.BufferedSource
import okio.ByteString
import okio.ForwardingSource
import okio.Source
import okio.buffer

/**
 * Streaming decoder of data encoded following Abstract Syntax Notation One (ASN.1). There are
 * multiple variants of ASN.1, including:
 *
 *  * DER: Distinguished Encoding Rules. This further constrains ASN.1 for deterministic encoding.

        context.setNotificationFilter(0x1F);

        // Test encoding and decoding roundtrip
        byte[] buffer = new byte[context.size()];
        int encoded = context.encode(buffer, 0);
        assertEquals(context.size(), encoded);

        DirectoryLeaseContext decodedContext = new DirectoryLeaseContext(new Smb2LeaseKey(), 0, DirectoryCacheScope.IMMEDIATE_CHILDREN);

		return key, err
	}
	err = key.Unseal(unsealKey, sealedKey, s3.String(), bucket, object)
	return key, err
}

// CreateMetadata encodes the sealed object key into the metadata and returns
// the modified metadata. If the keyID and the kmsKey is not empty it encodes
// both into the metadata as well. It allocates a new metadata map if metadata
// is nil.

	if err := w.prepare(fh); err != nil {
		return nil, err
	}

	// The ZIP format has a sad state of affairs regarding character encoding.
	// Officially, the name and comment fields are supposed to be encoded
	// in CP-437 (which is mostly compatible with ASCII), unless the UTF-8
	// flag bit is set. However, there are several problems:
	//
	//	* Many ZIP readers still do not support UTF-8.

            contextHandle = new byte[20];
        }
        buf.readOctetArray(contextHandle, 0, 20);
    }

    /**
     * Encodes a wide string pointer in NDR format.
     *
     * @param buf the NDR buffer
     * @param str the string to encode (can be null)
     * @throws NdrException if encoding fails
     */
    private void encodeWideStringPointer(NdrBuffer buf, String str) throws NdrException {