import java.io.File
import okio.FileSystem
import okio.Path.Companion.toPath

fun main(vararg args: String) {
  val data = loadIdnaMappingTableData()
  val file = generateMappingTableFile(data)
  file.writeTo(File(args[0]))
}

fun loadIdnaMappingTableData(): IdnaMappingTableData {
  val path = "/okhttp3/internal/idna/IdnaMappingTable.txt".toPath()
  val table =
    FileSystem.RESOURCES.read(path) {

	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return
	}

	var s strings.Builder
	for _, subSysConfig := range subSysConfigs {
		subSysConfig.WriteTo(&s, false)
	}

	password := cred.SecretKey
	econfigData, err := madmin.EncryptData(password, []byte(s.String()))
	if err != nil {
		writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
		return

    This simple option dramatically changes the behavior of the request body and of the entire
    call.

    The `RequestBody.writeTo()` method may now retain a reference to the provided sink and
    hand it off to another thread to write to it after `writeTo` returns.

    The `EventListener` may now see requests and responses interleaved in ways not previously

   * versions.
   */
  public byte[] toByteArray() {
    ByteBuffer buffer = ByteBuffer.allocate(BYTES).order(ByteOrder.LITTLE_ENDIAN);
    xStats.writeTo(buffer);
    yStats.writeTo(buffer);
    buffer.putDouble(sumOfProductsOfDeltas);
    return buffer.array();
  }

  /**
   * Creates a {@link PairedStats} instance from the given byte representation which was obtained by

        } else if (requestBody.isOneShot()) {
          logger.log("--> END ${request.method} (one-shot body omitted)")
        } else {
          var buffer = Buffer()
          requestBody.writeTo(buffer)

          var gzippedLength: Long? = null
          if ("gzip".equals(headers["Content-Encoding"], ignoreCase = true)) {
            gzippedLength = buffer.size

HSPLokhttp3/internal/_RequestBodyCommonKt$commonToRequestBody$1;->contentLength()J
HSPLokhttp3/internal/_RequestBodyCommonKt$commonToRequestBody$1;->contentType()Lokhttp3/MediaType;
HSPLokhttp3/internal/_RequestBodyCommonKt$commonToRequestBody$1;->writeTo(Lokio/BufferedSink;)V
HSPLokhttp3/internal/_ResponseBodyCommonKt$commonAsResponseBody$1;-><init>(Lokhttp3/MediaType;JLokio/BufferedSource;)V

                connection.connect(); // send type 3
                if (cachedOutput != null && doOutput) {
                    final OutputStream output = connection.getOutputStream();
                    cachedOutput.writeTo(output);
                    output.flush();
                }
                response = parseResponseCode();
                if (response != HTTP_UNAUTHORIZED && response != HTTP_PROXY_AUTH) {

          policy = response,
          socketEffect = response.onResponseBody,
          expectedByteCount = body.contentLength,
          socket = socket,
        ).buffer()
    body.writeTo(responseBodySink)
    responseBodySink.emit()

    socket.sleepWhileOpen(response.trailersDelayNanos)
    if ("chunked".equals(response.headers["Transfer-Encoding"], ignoreCase = true)) {

        append(" \\\n  -H ${"Content-Type: $contentType".shellEscape()}")
      }

      // Append body if present.
      if (includeBody && body != null) {
        val bodyBuffer = Buffer()
        body.writeTo(bodyBuffer)

        if (bodyBuffer.isProbablyUtf8()) {
          append(" \\\n  --data ${bodyBuffer.readUtf8().shellEscape()}")
        } else {

pkg go/types, method (*Scope) NumChildren() int
pkg go/types, method (*Scope) Parent() *Scope
pkg go/types, method (*Scope) Pos() token.Pos
pkg go/types, method (*Scope) String() string
pkg go/types, method (*Scope) WriteTo(io.Writer, int, bool)
pkg go/types, method (*Selection) Index() []int
pkg go/types, method (*Selection) Indirect() bool
pkg go/types, method (*Selection) Kind() SelectionKind
pkg go/types, method (*Selection) Obj() Object