@icure/cardinal-sdk 0.0.0-unspecified

package/ktor-ktor-http-ktor-http-cio.mjs

@@ -0,0 +1,1998 @@
+import {
+  Long2qws0ah9gnpki as Long,
+  VOID7hggqo3abtya as VOID,
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  NotImplementedErrorfzlkpv14xxr8 as NotImplementedError,
+  Unit_instance104q5opgivhr8 as Unit_instance,
+  toString1pkumu07cwy4m as toString,
+  IllegalArgumentException_init_$Create$310sysrobvll9 as IllegalArgumentException_init_$Create$,
+  StringBuilder_init_$Create$2mwec1027v00x as StringBuilder_init_$Create$,
+  _Char___init__impl__6a9atx281r2pd9o601g as _Char___init__impl__6a9atx,
+  endsWith1a79dp5rc3sfv as endsWith,
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  Char19o2r8palgjof as Char,
+  Char__compareTo_impl_ypi4mb3fw4vcbfqkuba as Char__compareTo_impl_ypi4mb,
+  contains2el4s70rdq4ld as contains,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+  Char__toInt_impl_vasixd2xlaiz5u3itpv as Char__toInt_impl_vasixd,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  IllegalStateException_init_$Init$13tvpwythio9e as IllegalStateException_init_$Init$,
+  captureStack1fzi4aczwc4hg as captureStack,
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  IllegalStateException_init_$Create$3ib9qa3pip8n4 as IllegalStateException_init_$Create$,
+  initMetadataForCoroutine1i7lbatuf5bnt as initMetadataForCoroutine,
+  setOf45ia9pnfhe90 as setOf,
+  listOf1jh22dvmctj1r as listOf,
+  toString1h6jjoch8cjt8 as toString_0,
+  toByte4i43936u611k as toByte,
+  copyOfRange3alro60z4hhf8 as copyOfRange,
+  startsWith641pyr7vf687 as startsWith,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  isInterface3d6p8outrmvmk as isInterface,
+  CancellationException_init_$Create$tastk7hwpe6q as CancellationException_init_$Create$,
+  toLongw1zpgk99d84b as toLong,
+  LinkedHashMap_init_$Create$1p3p95clvi93w as LinkedHashMap_init_$Create$,
+  ArrayList_init_$Create$2qnngtk1et9r9 as ArrayList_init_$Create$,
+  compareTo3ankvs086tmwq as compareTo,
+  NoSuchElementException_init_$Create$2u364tbvjhp4i as NoSuchElementException_init_$Create$,
+  Collection1k04j3hzsbod0 as Collection,
+  emptyList1g2z5xcrvp2zy as emptyList,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  StringBuilder_init_$Create$23o1ixl6cos5l as StringBuilder_init_$Create$_0,
+  isCharSequence1ju9jr1w86plq as isCharSequence,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  CharSequence1ceii1xorfwh7 as CharSequence,
+  IndexOutOfBoundsException_init_$Create$jb51qtvf74or as IndexOutOfBoundsException_init_$Create$,
+  charArray2ujmm1qusno00 as charArray,
+  NumberFormatException_init_$Create$kedeltz3bzwr as NumberFormatException_init_$Create$,
+  toString35i91qxh73cps as toString_1,
+  numberRangeToNumber25vse2rgp6rs8 as numberRangeToNumber,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$1s1wkrw82c0iw as ArrayList_init_$Create$_0,
+  numberToLong1a4cndvg6c52s as numberToLong,
+  toLongArray23ixicpzp5r3w as toLongArray,
+  Char__plus_impl_qi7pgj1zq2c0uiotg93 as Char__plus_impl_qi7pgj,
+  Char__minus_impl_a2frrhe8uo2lu35qi1 as Char__minus_impl_a2frrh,
+  toByteArray3caw0hip00os as toByteArray,
+  isWhitespace25occ8z1ed1s9 as isWhitespace,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  MultiPartData57syw40llxls as MultiPartData,
+  HttpHeaders_getInstancekqele34vb34f as HttpHeaders_getInstance,
+  MultiPart_getInstance2x0sgwr24mfqp as MultiPart_getInstance,
+  Companion_getInstancepumzx9q4106p as Companion_getInstance,
+} from './ktor-ktor-http.mjs';
+import {
+  CoroutineScopefcb5f5dwqcas as CoroutineScope,
+  produce1iljho2c8bp6o as produce,
+  ProducerScopeb3mmhvfa6ll7 as ProducerScope,
+  CompletableDeferred2lnqvsbvx74d3 as CompletableDeferred,
+} from './kotlinx-coroutines-core.mjs';
+import {
+  DefaultPool2gb1fm4epwgu9 as DefaultPool,
+  readUTF8LineTo2rqyj2iri7j7e as readUTF8LineTo,
+  Companion_getInstance2golwmcx6d471 as Companion_getInstance_0,
+  LineEndingMode__plus_impl_ttpz2j1fo728zjvbdzc as LineEndingMode__plus_impl_ttpz2j,
+  readUntilqaod88ylrtua as readUntil,
+  WriterScope3b0bo1enaee6b as WriterScope,
+  counted3iniv3aql3f9n as counted,
+  writer1eia5its2a1fh as writer,
+  readRemaining33cdmbznvdvtg as readRemaining,
+  get_remaining1lapv95kcmm0y as get_remaining,
+  skipIfFound2s927ggnjlzu8 as skipIfFound,
+  ByteChannel3cxdguezl3lu7 as ByteChannel,
+  close3semq7pafb42g as close,
+  readPacket12c3kakna35tv as readPacket,
+  copyTo2bqjr21is71ky as copyTo,
+  toByteArray1i3ns5jnoqlv6 as toByteArray_0,
+  NoPoolImplgos9n8jphzjp as NoPoolImpl,
+} from './ktor-ktor-io.mjs';
+import {
+  ByteString_init_$Create$szylcqpww4kx as ByteString_init_$Create$,
+  ByteString3c9fk8lsh3lvs as ByteString,
+} from './kotlinx-io-kotlinx-io-bytestring.mjs';
+import {
+  IOException_init_$Create$13y6ig657l2av as IOException_init_$Create$,
+  EOFException_init_$Create$1fcl7h9im3v9r as EOFException_init_$Create$,
+  IOException1wyutdmfe71nu as IOException,
+  IOException_init_$Init$2jjz3fe04l3kq as IOException_init_$Init$,
+} from './kotlinx-io-kotlinx-io-core.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+initMetadataForClass(CIOMultipartDataBase, 'CIOMultipartDataBase', VOID, VOID, [MultiPartData, CoroutineScope], [0, 1]);
+initMetadataForClass(HttpHeadersMap, 'HttpHeadersMap');
+initMetadataForClass(IntArrayPool$1, VOID, VOID, DefaultPool);
+initMetadataForClass(ParserException, 'ParserException', VOID, IllegalStateException);
+initMetadataForCoroutine($parseHeadersCOROUTINE$4, CoroutineImpl);
+initMetadataForClass(MultipartEvent, 'MultipartEvent');
+initMetadataForClass(Preamble, 'Preamble', VOID, MultipartEvent);
+initMetadataForClass(MultipartPart, 'MultipartPart', VOID, MultipartEvent);
+initMetadataForClass(Epilogue, 'Epilogue', VOID, MultipartEvent);
+initMetadataForLambda(parseMultipart$slambda$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForLambda(parseMultipart$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForCoroutine($parsePartHeadersImplCOROUTINE$5, CoroutineImpl);
+initMetadataForCoroutine($parsePartBodyImplCOROUTINE$6, CoroutineImpl);
+initMetadataForCoroutine($skipIfFoundReadCountCOROUTINE$7, CoroutineImpl);
+initMetadataForClass(Node, 'Node');
+initMetadataForCompanion(Companion);
+initMetadataForClass(AsciiCharTree, 'AsciiCharTree');
+initMetadataForClass(SubSequenceImpl, 'SubSequenceImpl', VOID, VOID, [CharSequence]);
+initMetadataForClass(CharArrayBuilder, 'CharArrayBuilder', CharArrayBuilder, VOID, [CharSequence]);
+initMetadataForClass(CharArrayPool$1, VOID, VOID, NoPoolImpl);
+initMetadataForClass(CharArrayPool$2, VOID, VOID, DefaultPool);
+initMetadataForClass(UnsupportedMediaTypeExceptionCIO, 'UnsupportedMediaTypeExceptionCIO', VOID, IOException);
+initMetadataForClass(MutableRange, 'MutableRange');
+//endregion
+function CIOMultipartDataBase(coroutineContext, channel, contentType, contentLength, formFieldLimit) {
+  formFieldLimit = formFieldLimit === VOID ? new Long(65536, 0) : formFieldLimit;
+  this.s34_1 = coroutineContext;
+  this.t34_1 = null;
+  this.u34_1 = parseMultipart(this, channel, contentType, contentLength, formFieldLimit);
+}
+protoOf(CIOMultipartDataBase).hp = function () {
+  return this.s34_1;
+};
+function get_EMPTY_INT_LIST() {
+  _init_properties_HttpHeadersMap_kt__hwatby();
+  return EMPTY_INT_LIST;
+}
+var EMPTY_INT_LIST;
+function get_IntArrayPool() {
+  _init_properties_HttpHeadersMap_kt__hwatby();
+  return IntArrayPool;
+}
+var IntArrayPool;
+function HttpHeadersMap(builder) {
+  this.v34_1 = builder;
+  this.w34_1 = 0;
+  this.x34_1 = get_IntArrayPool().n1z();
+}
+protoOf(HttpHeadersMap).y34 = function (nameHash, valueHash, nameStartIndex, nameEndIndex, valueStartIndex, valueEndIndex) {
+  var base = imul(this.w34_1, 8);
+  var array = this.x34_1;
+  if (base >= this.x34_1.length) {
+    // Inline function 'kotlin.TODO' call
+    var reason = 'Implement headers overflow';
+    throw new NotImplementedError('An operation is not implemented: ' + reason);
+  }
+  array[base + 0 | 0] = nameHash;
+  array[base + 1 | 0] = valueHash;
+  array[base + 2 | 0] = nameStartIndex;
+  array[base + 3 | 0] = nameEndIndex;
+  array[base + 4 | 0] = valueStartIndex;
+  array[base + 5 | 0] = valueEndIndex;
+  array[base + 6 | 0] = -1;
+  array[base + 7 | 0] = -1;
+  this.w34_1 = this.w34_1 + 1 | 0;
+};
+protoOf(HttpHeadersMap).o2m = function (name) {
+  var nameHash = hashCodeLowerCase(name);
+  var inductionVariable = 0;
+  var last = this.w34_1;
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var offset = imul(i, 8);
+      if (this.x34_1[offset] === nameHash) {
+        return this.v34_1.c(this.x34_1[offset + 4 | 0], this.x34_1[offset + 5 | 0]);
+      }
+    }
+     while (inductionVariable < last);
+  return null;
+};
+protoOf(HttpHeadersMap).g35 = function (idx) {
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(idx >= 0)) {
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(idx < this.w34_1)) {
+    var message_0 = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  var offset = imul(idx, 8);
+  var array = this.x34_1;
+  var nameStart = array[offset + 2 | 0];
+  var nameEnd = array[offset + 3 | 0];
+  return this.v34_1.c(nameStart, nameEnd);
+};
+protoOf(HttpHeadersMap).h35 = function (idx) {
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(idx >= 0)) {
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(idx < this.w34_1)) {
+    var message_0 = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  var offset = imul(idx, 8);
+  var array = this.x34_1;
+  var nameStart = array[offset + 4 | 0];
+  var nameEnd = array[offset + 5 | 0];
+  return this.v34_1.c(nameStart, nameEnd);
+};
+protoOf(HttpHeadersMap).z1g = function () {
+  this.w34_1 = 0;
+  var indexes = this.x34_1;
+  this.x34_1 = get_EMPTY_INT_LIST();
+  if (!(indexes === get_EMPTY_INT_LIST())) {
+    get_IntArrayPool().o1z(indexes);
+  }
+};
+protoOf(HttpHeadersMap).toString = function () {
+  // Inline function 'kotlin.text.buildString' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = StringBuilder_init_$Create$();
+  dumpTo(this, '', this_0);
+  return this_0.toString();
+};
+function dumpTo(_this__u8e3s4, indent, out) {
+  _init_properties_HttpHeadersMap_kt__hwatby();
+  var inductionVariable = 0;
+  var last = _this__u8e3s4.w34_1;
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      out.o(indent);
+      out.o(_this__u8e3s4.g35(i));
+      out.o(' => ');
+      out.o(_this__u8e3s4.h35(i));
+      out.o('\n');
+    }
+     while (inductionVariable < last);
+}
+function IntArrayPool$1() {
+  DefaultPool.call(this, 1000);
+}
+protoOf(IntArrayPool$1).g1z = function () {
+  return new Int32Array(4096);
+};
+var properties_initialized_HttpHeadersMap_kt_kotj4w;
+function _init_properties_HttpHeadersMap_kt__hwatby() {
+  if (!properties_initialized_HttpHeadersMap_kt_kotj4w) {
+    properties_initialized_HttpHeadersMap_kt_kotj4w = true;
+    EMPTY_INT_LIST = new Int32Array(0);
+    IntArrayPool = new IntArrayPool$1();
+  }
+}
+function get_hostForbiddenSymbols() {
+  _init_properties_HttpParser_kt__gbdom1();
+  return hostForbiddenSymbols;
+}
+var hostForbiddenSymbols;
+function get_httpLineEndings() {
+  _init_properties_HttpParser_kt__gbdom1();
+  return httpLineEndings;
+}
+var httpLineEndings;
+var versions;
+function parseHeaders(input, builder, range, $completion) {
+  range = range === VOID ? new MutableRange(0, 0) : range;
+  var tmp = new $parseHeadersCOROUTINE$4(input, builder, range, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+}
+function parseHeaderName(text, range) {
+  _init_properties_HttpParser_kt__gbdom1();
+  var index = range.x35_1;
+  var end = range.y35_1;
+  while (index < end) {
+    var ch = text.b(index);
+    if (ch === _Char___init__impl__6a9atx(58) && !(index === range.x35_1)) {
+      range.x35_1 = index + 1 | 0;
+      return index;
+    }
+    if (isDelimiter(ch)) {
+      parseHeaderNameFailed(text, index, range.x35_1, ch);
+    }
+    index = index + 1 | 0;
+  }
+  noColonFound(text, range);
+}
+function parseHeaderValue(text, range) {
+  _init_properties_HttpParser_kt__gbdom1();
+  var start = range.x35_1;
+  var end = range.y35_1;
+  var index = start;
+  index = skipSpacesAndHorizontalTabs(text, index, end);
+  if (index >= end) {
+    range.x35_1 = end;
+    return Unit_instance;
+  }
+  var valueStart = index;
+  var valueLastIndex = index;
+  while (index < end) {
+    var ch = text.b(index);
+    if (ch !== _Char___init__impl__6a9atx(9) && ch !== _Char___init__impl__6a9atx(32))
+      if (ch === _Char___init__impl__6a9atx(13) || ch === _Char___init__impl__6a9atx(10)) {
+        characterIsNotAllowed(text, ch);
+      } else
+        valueLastIndex = index;
+    index = index + 1 | 0;
+  }
+  range.x35_1 = valueStart;
+  range.y35_1 = valueLastIndex + 1 | 0;
+}
+function validateHostHeader(host) {
+  _init_properties_HttpParser_kt__gbdom1();
+  if (endsWith(host, ':')) {
+    throw new ParserException("Host header with ':' should contains port: " + toString(host));
+  }
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.text.any' call
+    var inductionVariable = 0;
+    while (inductionVariable < charSequenceLength(host)) {
+      var element = charSequenceGet(host, inductionVariable);
+      inductionVariable = inductionVariable + 1 | 0;
+      if (get_hostForbiddenSymbols().w(new Char(element))) {
+        tmp$ret$1 = true;
+        break $l$block;
+      }
+    }
+    tmp$ret$1 = false;
+  }
+  if (tmp$ret$1) {
+    throw new ParserException('Host cannot contain any of the following symbols: ' + toString(get_hostForbiddenSymbols()));
+  }
+}
+function isDelimiter(ch) {
+  _init_properties_HttpParser_kt__gbdom1();
+  return Char__compareTo_impl_ypi4mb(ch, _Char___init__impl__6a9atx(32)) <= 0 || contains('"(),/:;<=>?@[\\]{}', ch);
+}
+function parseHeaderNameFailed(text, index, start, ch) {
+  _init_properties_HttpParser_kt__gbdom1();
+  if (ch === _Char___init__impl__6a9atx(58)) {
+    throw new ParserException('Empty header names are not allowed as per RFC7230.');
+  }
+  if (index === start) {
+    throw new ParserException('Multiline headers via line folding is not supported since it is deprecated as per RFC7230.');
+  }
+  characterIsNotAllowed(text, ch);
+}
+function noColonFound(text, range) {
+  _init_properties_HttpParser_kt__gbdom1();
+  var tmp1 = range.x35_1;
+  // Inline function 'kotlin.text.substring' call
+  var endIndex = range.y35_1;
+  var tmp$ret$0 = toString(charSequenceSubSequence(text, tmp1, endIndex));
+  throw new ParserException('No colon in HTTP header in ' + tmp$ret$0 + ' in builder: \n' + toString(text));
+}
+function characterIsNotAllowed(text, ch) {
+  _init_properties_HttpParser_kt__gbdom1();
+  // Inline function 'kotlin.code' call
+  var tmp$ret$0 = Char__toInt_impl_vasixd(ch);
+  throw new ParserException('Character with code ' + (tmp$ret$0 & 255) + ' is not allowed in header names, \n' + toString(text));
+}
+function ParserException(message) {
+  IllegalStateException_init_$Init$(message, this);
+  captureStack(this, ParserException);
+}
+function $parseHeadersCOROUTINE$4(input, builder, range, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.t35_1 = input;
+  this.u35_1 = builder;
+  this.v35_1 = range;
+}
+protoOf($parseHeadersCOROUTINE$4).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 7;
+          this.w35_1 = new HttpHeadersMap(this.u35_1);
+          this.k9_1 = 6;
+          this.j9_1 = 1;
+          continue $sm;
+        case 1:
+          if (!true) {
+            this.j9_1 = 5;
+            continue $sm;
+          }
+
+          this.j9_1 = 2;
+          suspendResult = readUTF8LineTo(this.t35_1, this.u35_1, 8192, get_httpLineEndings(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          var ARGUMENT = suspendResult;
+          if (!ARGUMENT) {
+            this.w35_1.z1g();
+            return null;
+          } else {
+            this.j9_1 = 3;
+            continue $sm;
+          }
+
+        case 3:
+          this.v35_1.y35_1 = this.u35_1.f35_1;
+          var rangeLength = this.v35_1.y35_1 - this.v35_1.x35_1 | 0;
+          if (rangeLength === 0) {
+            this.j9_1 = 5;
+            continue $sm;
+          } else {
+            this.j9_1 = 4;
+            continue $sm;
+          }
+
+        case 4:
+          if (rangeLength >= 8192) {
+            var message = 'Header line length limit exceeded';
+            throw IllegalStateException_init_$Create$(toString(message));
+          }
+
+          var nameStart = this.v35_1.x35_1;
+          var nameEnd = parseHeaderName(this.u35_1, this.v35_1);
+          var nameHash = hashCodeLowerCase(this.u35_1, nameStart, nameEnd);
+          var headerEnd = this.v35_1.y35_1;
+          parseHeaderValue(this.u35_1, this.v35_1);
+          var valueStart = this.v35_1.x35_1;
+          var valueEnd = this.v35_1.y35_1;
+          var valueHash = hashCodeLowerCase(this.u35_1, valueStart, valueEnd);
+          this.v35_1.x35_1 = headerEnd;
+          this.w35_1.y34(nameHash, valueHash, nameStart, nameEnd, valueStart, valueEnd);
+          this.j9_1 = 1;
+          continue $sm;
+        case 5:
+          var host = this.w35_1.o2m(HttpHeaders_getInstance().s2v_1);
+          if (!(host == null)) {
+            validateHostHeader(host);
+          }
+
+          return this.w35_1;
+        case 6:
+          this.k9_1 = 7;
+          var tmp_0 = this.m9_1;
+          if (tmp_0 instanceof Error) {
+            var t = this.m9_1;
+            this.w35_1.z1g();
+            throw t;
+          } else {
+            throw this.m9_1;
+          }
+
+        case 7:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 7) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+var properties_initialized_HttpParser_kt_uedryv;
+function _init_properties_HttpParser_kt__gbdom1() {
+  if (!properties_initialized_HttpParser_kt_uedryv) {
+    properties_initialized_HttpParser_kt_uedryv = true;
+    hostForbiddenSymbols = setOf([new Char(_Char___init__impl__6a9atx(47)), new Char(_Char___init__impl__6a9atx(63)), new Char(_Char___init__impl__6a9atx(35)), new Char(_Char___init__impl__6a9atx(64))]);
+    httpLineEndings = LineEndingMode__plus_impl_ttpz2j(Companion_getInstance_0().t1s_1, Companion_getInstance_0().s1s_1);
+    versions = Companion_instance.z35(listOf(['HTTP/1.0', 'HTTP/1.1']));
+  }
+}
+function get_CrLf() {
+  _init_properties_Multipart_kt__ato98a();
+  return CrLf;
+}
+var CrLf;
+function get_PrefixString() {
+  _init_properties_Multipart_kt__ato98a();
+  return PrefixString;
+}
+var PrefixString;
+function Preamble(body) {
+  MultipartEvent.call(this);
+  this.a36_1 = body;
+}
+function MultipartPart(headers, body) {
+  MultipartEvent.call(this);
+  this.b36_1 = headers;
+  this.c36_1 = body;
+}
+function Epilogue(body) {
+  MultipartEvent.call(this);
+  this.d36_1 = body;
+}
+function MultipartEvent() {
+}
+function parseMultipart(_this__u8e3s4, input, contentType, contentLength, maxPartSize) {
+  maxPartSize = maxPartSize === VOID ? new Long(-1, 2147483647) : maxPartSize;
+  _init_properties_Multipart_kt__ato98a();
+  if (!MultiPart_getInstance().i2t(contentType)) {
+    throw new UnsupportedMediaTypeExceptionCIO('Failed to parse multipart: Content-Type should be multipart/* but it is ' + toString(contentType));
+  }
+  var boundaryByteBuffer = parseBoundaryInternal(contentType);
+  var boundaryBytes = ByteString_init_$Create$(boundaryByteBuffer);
+  return parseMultipart_0(_this__u8e3s4, boundaryBytes, input, contentLength, maxPartSize);
+}
+function parseBoundaryInternal(contentType) {
+  _init_properties_Multipart_kt__ato98a();
+  var boundaryParameter = findBoundary(contentType);
+  if (boundaryParameter === -1) {
+    throw IOException_init_$Create$("Failed to parse multipart: Content-Type's boundary parameter is missing");
+  }
+  var boundaryStart = boundaryParameter + 9 | 0;
+  var boundaryBytes = new Int8Array(74);
+  var position = {_v: 0};
+  parseBoundaryInternal$put(position, boundaryBytes, 13);
+  parseBoundaryInternal$put(position, boundaryBytes, 10);
+  parseBoundaryInternal$put(position, boundaryBytes, 45);
+  parseBoundaryInternal$put(position, boundaryBytes, 45);
+  var state = 0;
+  var inductionVariable = boundaryStart;
+  var last = charSequenceLength(contentType);
+  if (inductionVariable < last)
+    loop: do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var ch = charSequenceGet(contentType, i);
+      // Inline function 'kotlin.code' call
+      var v = Char__toInt_impl_vasixd(ch) & 65535;
+      if ((v & 65535) > 127) {
+        throw IOException_init_$Create$('Failed to parse multipart: wrong boundary byte 0x' + toString_0(v, 16) + ' - should be 7bit character');
+      }
+      switch (state) {
+        case 0:
+          if (ch !== _Char___init__impl__6a9atx(32))
+            if (ch === _Char___init__impl__6a9atx(34)) {
+              state = 2;
+            } else if (ch === _Char___init__impl__6a9atx(59) || ch === _Char___init__impl__6a9atx(44)) {
+              break loop;
+            } else {
+              state = 1;
+              parseBoundaryInternal$put(position, boundaryBytes, toByte(v));
+            }
+
+          break;
+        case 1:
+          if (ch === _Char___init__impl__6a9atx(32) || ch === _Char___init__impl__6a9atx(44) || ch === _Char___init__impl__6a9atx(59)) {
+            break loop;
+          } else {
+            parseBoundaryInternal$put(position, boundaryBytes, toByte(v));
+          }
+
+          break;
+        case 2:
+          if (ch === _Char___init__impl__6a9atx(92)) {
+            state = 3;
+          } else if (ch === _Char___init__impl__6a9atx(34)) {
+            break loop;
+          } else {
+            parseBoundaryInternal$put(position, boundaryBytes, toByte(v));
+          }
+
+          break;
+        case 3:
+          parseBoundaryInternal$put(position, boundaryBytes, toByte(v));
+          state = 2;
+          break;
+      }
+    }
+     while (inductionVariable < last);
+  if (position._v === 4) {
+    throw IOException_init_$Create$('Empty multipart boundary is not allowed');
+  }
+  return copyOfRange(boundaryBytes, 0, position._v);
+}
+function parseMultipart_0(_this__u8e3s4, boundaryPrefixed, input, totalLength, maxPartSize) {
+  _init_properties_Multipart_kt__ato98a();
+  return produce(_this__u8e3s4, VOID, VOID, parseMultipart$slambda_0(input, boundaryPrefixed, maxPartSize, totalLength, null));
+}
+function findBoundary(contentType) {
+  _init_properties_Multipart_kt__ato98a();
+  var state = 0;
+  var paramNameCount = 0;
+  var inductionVariable = 0;
+  var last = charSequenceLength(contentType) - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var ch = charSequenceGet(contentType, i);
+      switch (state) {
+        case 0:
+          if (ch === _Char___init__impl__6a9atx(59)) {
+            state = 1;
+            paramNameCount = 0;
+          }
+
+          break;
+        case 1:
+          if (ch === _Char___init__impl__6a9atx(61)) {
+            state = 2;
+          } else if (ch === _Char___init__impl__6a9atx(59)) {
+            paramNameCount = 0;
+          } else if (ch === _Char___init__impl__6a9atx(44)) {
+            state = 0;
+          } else if (ch !== _Char___init__impl__6a9atx(32))
+            if (paramNameCount === 0 && startsWith(contentType, 'boundary=', i, true)) {
+              return i;
+            } else {
+              paramNameCount = paramNameCount + 1 | 0;
+            }
+
+          break;
+        case 2:
+          if (ch === _Char___init__impl__6a9atx(34))
+            state = 3;
+          else if (ch === _Char___init__impl__6a9atx(44))
+            state = 0;
+          else if (ch === _Char___init__impl__6a9atx(59)) {
+            state = 1;
+            paramNameCount = 0;
+          }
+
+          break;
+        case 3:
+          if (ch === _Char___init__impl__6a9atx(34)) {
+            state = 1;
+            paramNameCount = 0;
+          } else if (ch === _Char___init__impl__6a9atx(92)) {
+            state = 4;
+          }
+
+          break;
+        case 4:
+          state = 3;
+          break;
+      }
+    }
+     while (inductionVariable <= last);
+  return -1;
+}
+function parsePreambleImpl(boundary, input, output, limit, $completion) {
+  limit = limit === VOID ? new Long(-1, 2147483647) : limit;
+  return readUntil(input, boundary, output, limit, true, $completion);
+}
+function parsePartHeadersImpl(input, $completion) {
+  var tmp = new $parsePartHeadersImplCOROUTINE$5(input, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+}
+function parsePartBodyImpl(boundaryPrefixed, input, output, headers, limit, $completion) {
+  var tmp = new $parsePartBodyImplCOROUTINE$6(boundaryPrefixed, input, output, headers, limit, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+}
+function skipIfFoundReadCount(_this__u8e3s4, prefix, $completion) {
+  var tmp = new $skipIfFoundReadCountCOROUTINE$7(_this__u8e3s4, prefix, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+}
+function throwLimitExceeded(actual, limit) {
+  _init_properties_Multipart_kt__ato98a();
+  throw IOException_init_$Create$('Multipart content length exceeds limit ' + actual.toString() + ' > ' + limit.toString() + '; ' + "limit is defined using 'formFieldLimit' argument");
+}
+function parseBoundaryInternal$put(position, boundaryBytes, value) {
+  if (position._v >= boundaryBytes.length) {
+    throw IOException_init_$Create$("Failed to parse multipart: boundary shouldn't be longer than 70 characters");
+  }
+  var _unary__edvuaz = position._v;
+  position._v = _unary__edvuaz + 1 | 0;
+  boundaryBytes[_unary__edvuaz] = value;
+}
+function parseMultipart$slambda$slambda($firstBoundary, $countedInput, resultContinuation) {
+  this.z37_1 = $firstBoundary;
+  this.a38_1 = $countedInput;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(parseMultipart$slambda$slambda).c38 = function ($this$writer, $completion) {
+  var tmp = this.d38($this$writer, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(parseMultipart$slambda$slambda).fa = function (p1, $completion) {
+  return this.c38(p1 instanceof WriterScope ? p1 : THROW_CCE(), $completion);
+};
+protoOf(parseMultipart$slambda$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 3;
+          this.j9_1 = 1;
+          suspendResult = parsePreambleImpl(this.z37_1, this.a38_1, this.b38_1.k1w_1, new Long(8193, 0), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.j9_1 = 2;
+          suspendResult = this.b38_1.k1w_1.l1p(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          return Unit_instance;
+        case 3:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 3) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(parseMultipart$slambda$slambda).d38 = function ($this$writer, completion) {
+  var i = new parseMultipart$slambda$slambda(this.z37_1, this.a38_1, completion);
+  i.b38_1 = $this$writer;
+  return i;
+};
+function parseMultipart$slambda$slambda_0($firstBoundary, $countedInput, resultContinuation) {
+  var i = new parseMultipart$slambda$slambda($firstBoundary, $countedInput, resultContinuation);
+  var l = function ($this$writer, $completion) {
+    return i.c38($this$writer, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function parseMultipart$slambda($input, $boundaryPrefixed, $maxPartSize, $totalLength, resultContinuation) {
+  this.m38_1 = $input;
+  this.n38_1 = $boundaryPrefixed;
+  this.o38_1 = $maxPartSize;
+  this.p38_1 = $totalLength;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(parseMultipart$slambda).h39 = function ($this$produce, $completion) {
+  var tmp = this.i39($this$produce, $completion);
+  tmp.l9_1 = Unit_instance;
+  tmp.m9_1 = null;
+  return tmp.r9();
+};
+protoOf(parseMultipart$slambda).fa = function (p1, $completion) {
+  return this.h39((!(p1 == null) ? isInterface(p1, ProducerScope) : false) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(parseMultipart$slambda).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 23;
+          this.r38_1 = counted(this.m38_1);
+          this.s38_1 = this.r38_1.u1y();
+          this.t38_1 = this.n38_1.m1j(get_PrefixString().s());
+          this.j9_1 = 1;
+          suspendResult = readRemaining(writer(this.q38_1, VOID, VOID, parseMultipart$slambda$slambda_0(this.t38_1, this.r38_1, null)).i1w_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          this.u38_1 = suspendResult;
+          if (get_remaining(this.u38_1).g1(new Long(0, 0)) > 0) {
+            this.j9_1 = 2;
+            suspendResult = this.q38_1.r18(new Preamble(this.u38_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j9_1 = 3;
+            continue $sm;
+          }
+
+        case 2:
+          this.j9_1 = 3;
+          continue $sm;
+        case 3:
+          this.j9_1 = 4;
+          continue $sm;
+        case 4:
+          if (!this.r38_1.i1p()) {
+            this.j9_1 = 5;
+            suspendResult = skipIfFound(this.r38_1, get_PrefixString(), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.v38_1 = false;
+            this.j9_1 = 6;
+            continue $sm;
+          }
+
+        case 5:
+          this.w38_1 = suspendResult;
+          this.v38_1 = !this.w38_1;
+          this.j9_1 = 6;
+          continue $sm;
+        case 6:
+          if (!this.v38_1) {
+            this.j9_1 = 13;
+            continue $sm;
+          }
+
+          this.j9_1 = 7;
+          suspendResult = skipIfFound(this.r38_1, get_CrLf(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 7:
+          this.x38_1 = new ByteChannel();
+          this.y38_1 = CompletableDeferred();
+          this.z38_1 = new MultipartPart(this.y38_1, this.x38_1);
+          this.j9_1 = 8;
+          suspendResult = this.q38_1.r18(this.z38_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 8:
+          this.a39_1 = null;
+          this.k9_1 = 12;
+          this.j9_1 = 9;
+          suspendResult = parsePartHeadersImpl(this.r38_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 9:
+          this.a39_1 = suspendResult;
+          if (!this.y38_1.aw(this.a39_1)) {
+            this.a39_1.z1g();
+            throw CancellationException_init_$Create$('Multipart processing has been cancelled');
+          }
+
+          this.j9_1 = 10;
+          suspendResult = parsePartBodyImpl(this.n38_1, this.r38_1, this.x38_1, this.a39_1, this.o38_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 10:
+          this.x38_1.p4();
+          this.k9_1 = 23;
+          this.j9_1 = 11;
+          continue $sm;
+        case 11:
+          this.k9_1 = 23;
+          this.j9_1 = 4;
+          continue $sm;
+        case 12:
+          this.k9_1 = 23;
+          var tmp_0 = this.m9_1;
+          if (tmp_0 instanceof Error) {
+            this.b39_1 = this.m9_1;
+            if (this.y38_1.cw(this.b39_1)) {
+              var tmp0_safe_receiver = this.a39_1;
+              if (tmp0_safe_receiver == null)
+                null;
+              else {
+                tmp0_safe_receiver.z1g();
+              }
+            }
+            close(this.x38_1, this.b39_1);
+            throw this.b39_1;
+          } else {
+            throw this.m9_1;
+          }
+
+        case 13:
+          this.j9_1 = 14;
+          suspendResult = skipIfFound(this.r38_1, get_CrLf(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 14:
+          this.j9_1 = 15;
+          suspendResult = skipIfFound(this.r38_1, get_CrLf(), this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 15:
+          if (!(this.p38_1 == null)) {
+            this.c39_1 = this.r38_1.u1y().c3(this.s38_1);
+            this.d39_1 = this.p38_1.c3(this.c39_1);
+            if (this.d39_1.g1(new Long(2147483647, 0)) > 0)
+              throw IOException_init_$Create$('Failed to parse multipart: prologue is too long');
+            if (this.d39_1.g1(new Long(0, 0)) > 0) {
+              this.j9_1 = 19;
+              suspendResult = readPacket(this.r38_1, this.d39_1.l1(), this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.j9_1 = 21;
+              continue $sm;
+            }
+          } else {
+            this.j9_1 = 16;
+            suspendResult = readRemaining(this.r38_1, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          }
+
+        case 16:
+          this.e39_1 = suspendResult;
+          if (!this.e39_1.u1j()) {
+            this.j9_1 = 17;
+            suspendResult = this.q38_1.r18(new Epilogue(this.e39_1), this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            this.j9_1 = 18;
+            continue $sm;
+          }
+
+        case 17:
+          this.j9_1 = 18;
+          continue $sm;
+        case 18:
+          this.j9_1 = 22;
+          continue $sm;
+        case 19:
+          this.f39_1 = suspendResult;
+          this.g39_1 = new Epilogue(this.f39_1);
+          this.j9_1 = 20;
+          suspendResult = this.q38_1.r18(this.g39_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 20:
+          this.j9_1 = 21;
+          continue $sm;
+        case 21:
+          this.j9_1 = 22;
+          continue $sm;
+        case 22:
+          return Unit_instance;
+        case 23:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 23) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(parseMultipart$slambda).i39 = function ($this$produce, completion) {
+  var i = new parseMultipart$slambda(this.m38_1, this.n38_1, this.o38_1, this.p38_1, completion);
+  i.q38_1 = $this$produce;
+  return i;
+};
+function parseMultipart$slambda_0($input, $boundaryPrefixed, $maxPartSize, $totalLength, resultContinuation) {
+  var i = new parseMultipart$slambda($input, $boundaryPrefixed, $maxPartSize, $totalLength, resultContinuation);
+  var l = function ($this$produce, $completion) {
+    return i.h39($this$produce, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function $parsePartHeadersImplCOROUTINE$5(input, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.m36_1 = input;
+}
+protoOf($parsePartHeadersImplCOROUTINE$5).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 3;
+          this.n36_1 = new CharArrayBuilder();
+          this.k9_1 = 2;
+          this.j9_1 = 1;
+          suspendResult = parseHeaders(this.m36_1, this.n36_1, VOID, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var tmp0_elvis_lhs = suspendResult;
+          var tmp_0;
+          if (tmp0_elvis_lhs == null) {
+            throw EOFException_init_$Create$('Failed to parse multipart headers: unexpected end of stream');
+          } else {
+            tmp_0 = tmp0_elvis_lhs;
+          }
+
+          return tmp_0;
+        case 2:
+          this.k9_1 = 3;
+          var tmp_1 = this.m9_1;
+          if (tmp_1 instanceof Error) {
+            var t = this.m9_1;
+            this.n36_1.z1g();
+            throw t;
+          } else {
+            throw this.m9_1;
+          }
+
+        case 3:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 3) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function $parsePartBodyImplCOROUTINE$6(boundaryPrefixed, input, output, headers, limit, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.w36_1 = boundaryPrefixed;
+  this.x36_1 = input;
+  this.y36_1 = output;
+  this.z36_1 = headers;
+  this.a37_1 = limit;
+}
+protoOf($parsePartBodyImplCOROUTINE$6).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 6;
+          var tmp_0 = this;
+          var tmp0_safe_receiver = this.z36_1.o2m('Content-Length');
+          tmp_0.b37_1 = tmp0_safe_receiver == null ? null : parseDecLong(tmp0_safe_receiver);
+          if (this.b37_1 == null) {
+            this.j9_1 = 3;
+            suspendResult = readUntil(this.x36_1, this.w36_1, this.y36_1, this.a37_1, true, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+            continue $sm;
+          } else {
+            if ((new Long(0, 0)).k3(this.a37_1).ij(this.b37_1)) {
+              this.j9_1 = 1;
+              suspendResult = copyTo(this.x36_1, this.y36_1, this.b37_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              var tmp_1 = this;
+              throwLimitExceeded(this.b37_1, this.a37_1);
+            }
+          }
+
+          break;
+        case 1:
+          this.d37_1 = suspendResult;
+          this.j9_1 = 2;
+          suspendResult = skipIfFoundReadCount(this.x36_1, this.w36_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 2:
+          this.e37_1 = suspendResult;
+          this.c37_1 = this.d37_1.b3(this.e37_1);
+          this.j9_1 = 4;
+          continue $sm;
+        case 3:
+          this.c37_1 = suspendResult;
+          this.j9_1 = 4;
+          continue $sm;
+        case 4:
+          this.f37_1 = this.c37_1;
+          this.j9_1 = 5;
+          suspendResult = this.y36_1.a1p(this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 5:
+          return this.f37_1;
+        case 6:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 6) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+function $skipIfFoundReadCountCOROUTINE$7(_this__u8e3s4, prefix, resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+  this.o37_1 = _this__u8e3s4;
+  this.p37_1 = prefix;
+}
+protoOf($skipIfFoundReadCountCOROUTINE$7).r9 = function () {
+  var suspendResult = this.l9_1;
+  $sm: do
+    try {
+      var tmp = this.j9_1;
+      switch (tmp) {
+        case 0:
+          this.k9_1 = 3;
+          this.j9_1 = 1;
+          suspendResult = skipIfFound(this.o37_1, this.p37_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          if (suspendResult) {
+            var tmp_0 = this;
+            tmp_0.q37_1 = toLong(this.p37_1.s());
+            this.j9_1 = 2;
+            continue $sm;
+          } else {
+            var tmp_1 = this;
+            tmp_1.q37_1 = new Long(0, 0);
+            this.j9_1 = 2;
+            continue $sm;
+          }
+
+        case 2:
+          return this.q37_1;
+        case 3:
+          throw this.m9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.k9_1 === 3) {
+        throw e;
+      } else {
+        this.j9_1 = this.k9_1;
+        this.m9_1 = e;
+      }
+    }
+   while (true);
+};
+var properties_initialized_Multipart_kt_wu0sh0;
+function _init_properties_Multipart_kt__ato98a() {
+  if (!properties_initialized_Multipart_kt_wu0sh0) {
+    properties_initialized_Multipart_kt_wu0sh0 = true;
+    CrLf = ByteString_init_$Create$(toByteArray_0('\r\n'));
+    PrefixString = ByteString(new Int8Array([45, 45]));
+  }
+}
+function build($this, resultList, from, maxLength, idx, length, charAt) {
+  // Inline function 'kotlin.collections.groupBy' call
+  // Inline function 'kotlin.collections.groupByTo' call
+  var destination = LinkedHashMap_init_$Create$();
+  var _iterator__ex2g4s = from.p();
+  while (_iterator__ex2g4s.q()) {
+    var element = _iterator__ex2g4s.r();
+    var key = charAt(element, idx);
+    // Inline function 'kotlin.collections.getOrPut' call
+    var value = destination.o2(key);
+    var tmp;
+    if (value == null) {
+      var answer = ArrayList_init_$Create$();
+      destination.r2(key, answer);
+      tmp = answer;
+    } else {
+      tmp = value;
+    }
+    var list = tmp;
+    list.k(element);
+  }
+  // Inline function 'kotlin.collections.forEach' call
+  // Inline function 'kotlin.collections.iterator' call
+  var _iterator__ex2g4s_0 = destination.z().p();
+  while (_iterator__ex2g4s_0.q()) {
+    var element_0 = _iterator__ex2g4s_0.r();
+    // Inline function 'kotlin.collections.component1' call
+    var ch = element_0.a1().t1_1;
+    // Inline function 'kotlin.collections.component2' call
+    var list_0 = element_0.b1();
+    var nextIdx = idx + 1 | 0;
+    var children = ArrayList_init_$Create$();
+    var tmp_0 = Companion_instance;
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination_0 = ArrayList_init_$Create$();
+    var _iterator__ex2g4s_1 = list_0.p();
+    while (_iterator__ex2g4s_1.q()) {
+      var element_1 = _iterator__ex2g4s_1.r();
+      if (length(element_1) > nextIdx) {
+        destination_0.k(element_1);
+      }
+    }
+    build(tmp_0, children, destination_0, maxLength, nextIdx, length, charAt);
+    children.z5();
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination_1 = ArrayList_init_$Create$();
+    var _iterator__ex2g4s_2 = list_0.p();
+    while (_iterator__ex2g4s_2.q()) {
+      var element_2 = _iterator__ex2g4s_2.r();
+      if (length(element_2) === nextIdx) {
+        destination_1.k(element_2);
+      }
+    }
+    resultList.k(new Node(ch, destination_1, children));
+  }
+}
+function AsciiCharTree$Companion$build$lambda(it) {
+  return charSequenceLength(it);
+}
+function AsciiCharTree$Companion$build$lambda_0(s, idx) {
+  return new Char(charSequenceGet(s, idx));
+}
+function Node(ch, exact, children) {
+  this.j39_1 = ch;
+  this.k39_1 = exact;
+  this.l39_1 = children;
+  var tmp = this;
+  var tmp_0 = 0;
+  // Inline function 'kotlin.arrayOfNulls' call
+  var tmp_1 = Array(256);
+  while (tmp_0 < 256) {
+    var tmp_2 = tmp_0;
+    var tmp1 = this.l39_1;
+    var tmp$ret$3;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.singleOrNull' call
+      var single = null;
+      var found = false;
+      var _iterator__ex2g4s = tmp1.p();
+      while (_iterator__ex2g4s.q()) {
+        var element = _iterator__ex2g4s.r();
+        // Inline function 'kotlin.code' call
+        var this_0 = element.j39_1;
+        if (Char__toInt_impl_vasixd(this_0) === tmp_2) {
+          if (found) {
+            tmp$ret$3 = null;
+            break $l$block_0;
+          }
+          single = element;
+          found = true;
+        }
+      }
+      if (!found) {
+        tmp$ret$3 = null;
+        break $l$block_0;
+      }
+      tmp$ret$3 = single;
+    }
+    tmp_1[tmp_2] = tmp$ret$3;
+    tmp_0 = tmp_0 + 1 | 0;
+  }
+  tmp.m39_1 = tmp_1;
+}
+function Companion() {
+}
+protoOf(Companion).z35 = function (from) {
+  var tmp = AsciiCharTree$Companion$build$lambda;
+  return this.n39(from, tmp, AsciiCharTree$Companion$build$lambda_0);
+};
+protoOf(Companion).n39 = function (from, length, charAt) {
+  var tmp$ret$0;
+  $l$block_0: {
+    // Inline function 'kotlin.collections.maxByOrNull' call
+    var iterator = from.p();
+    if (!iterator.q()) {
+      tmp$ret$0 = null;
+      break $l$block_0;
+    }
+    var maxElem = iterator.r();
+    if (!iterator.q()) {
+      tmp$ret$0 = maxElem;
+      break $l$block_0;
+    }
+    var maxValue = length(maxElem);
+    do {
+      var e = iterator.r();
+      var v = length(e);
+      if (compareTo(maxValue, v) < 0) {
+        maxElem = e;
+        maxValue = v;
+      }
+    }
+     while (iterator.q());
+    tmp$ret$0 = maxElem;
+  }
+  var tmp0_safe_receiver = tmp$ret$0;
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    tmp = length(tmp0_safe_receiver);
+  }
+  var tmp1_elvis_lhs = tmp;
+  var tmp_0;
+  if (tmp1_elvis_lhs == null) {
+    throw NoSuchElementException_init_$Create$('Unable to build char tree from an empty list');
+  } else {
+    tmp_0 = tmp1_elvis_lhs;
+  }
+  var maxLen = tmp_0;
+  var tmp$ret$2;
+  $l$block_2: {
+    // Inline function 'kotlin.collections.any' call
+    var tmp_1;
+    if (isInterface(from, Collection)) {
+      tmp_1 = from.h();
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      tmp$ret$2 = false;
+      break $l$block_2;
+    }
+    var _iterator__ex2g4s = from.p();
+    while (_iterator__ex2g4s.q()) {
+      var element = _iterator__ex2g4s.r();
+      if (length(element) === 0) {
+        tmp$ret$2 = true;
+        break $l$block_2;
+      }
+    }
+    tmp$ret$2 = false;
+  }
+  if (tmp$ret$2)
+    throw IllegalArgumentException_init_$Create$('There should be no empty entries');
+  var root = ArrayList_init_$Create$();
+  build(this, root, from, maxLen, 0, length, charAt);
+  root.z5();
+  return new AsciiCharTree(new Node(_Char___init__impl__6a9atx(0), emptyList(), root));
+};
+var Companion_instance;
+function Companion_getInstance_1() {
+  return Companion_instance;
+}
+function AsciiCharTree(root) {
+  this.o39_1 = root;
+}
+function getImpl($this, index) {
+  return bufferForIndex($this, index)[index % ensureNotNull($this.b35_1).length | 0];
+}
+function copy($this, startIndex, endIndex) {
+  if (startIndex === endIndex)
+    return '';
+  var builder = StringBuilder_init_$Create$_0(endIndex - startIndex | 0);
+  var buffer;
+  var base = startIndex - (startIndex % 2048 | 0) | 0;
+  while (base < endIndex) {
+    buffer = bufferForIndex($this, base);
+    // Inline function 'kotlin.comparisons.maxOf' call
+    var b = startIndex - base | 0;
+    var innerStartIndex = Math.max(0, b);
+    // Inline function 'kotlin.comparisons.minOf' call
+    var a = endIndex - base | 0;
+    var innerEndIndex = Math.min(a, 2048);
+    var inductionVariable = innerStartIndex;
+    if (inductionVariable < innerEndIndex)
+      do {
+        var innerIndex = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        builder.r8(buffer[innerIndex]);
+      }
+       while (inductionVariable < innerEndIndex);
+    base = base + 2048 | 0;
+  }
+  return builder;
+}
+function SubSequenceImpl($outer, start, end) {
+  this.s39_1 = $outer;
+  this.p39_1 = start;
+  this.q39_1 = end;
+  this.r39_1 = null;
+}
+protoOf(SubSequenceImpl).a = function () {
+  return this.q39_1 - this.p39_1 | 0;
+};
+protoOf(SubSequenceImpl).b = function (index) {
+  var withOffset = index + this.p39_1 | 0;
+  // Inline function 'kotlin.require' call
+  if (!(index >= 0)) {
+    var message = 'index is negative: ' + index;
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(withOffset < this.q39_1)) {
+    var message_0 = 'index (' + index + ') should be less than length (' + this.a() + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  return getImpl(this.s39_1, withOffset);
+};
+protoOf(SubSequenceImpl).c = function (startIndex, endIndex) {
+  // Inline function 'kotlin.require' call
+  if (!(startIndex >= 0)) {
+    var message = 'start is negative: ' + startIndex;
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(startIndex <= endIndex)) {
+    var message_0 = 'start (' + startIndex + ') should be less or equal to end (' + endIndex + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(endIndex <= (this.q39_1 - this.p39_1 | 0))) {
+    var message_1 = 'end should be less than length (' + this.a() + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_1));
+  }
+  if (startIndex === endIndex)
+    return '';
+  return new SubSequenceImpl(this.s39_1, this.p39_1 + startIndex | 0, this.p39_1 + endIndex | 0);
+};
+protoOf(SubSequenceImpl).toString = function () {
+  var tmp0_elvis_lhs = this.r39_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlin.also' call
+    var this_0 = toString(copy(this.s39_1, this.p39_1, this.q39_1));
+    this.r39_1 = this_0;
+    tmp = this_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+};
+protoOf(SubSequenceImpl).equals = function (other) {
+  if (!(!(other == null) ? isCharSequence(other) : false))
+    return false;
+  if (!(charSequenceLength(other) === this.a()))
+    return false;
+  return rangeEqualsImpl(this.s39_1, this.p39_1, other, 0, this.a());
+};
+protoOf(SubSequenceImpl).hashCode = function () {
+  var tmp0_safe_receiver = this.r39_1;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : getStringHashCode(tmp0_safe_receiver);
+  return tmp1_elvis_lhs == null ? hashCodeImpl(this.s39_1, this.p39_1, this.q39_1) : tmp1_elvis_lhs;
+};
+function bufferForIndex($this, index) {
+  var list = $this.a35_1;
+  if (list == null) {
+    if (index >= 2048) {
+      throwSingleBuffer($this, index);
+    }
+    var tmp0_elvis_lhs = $this.b35_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throwSingleBuffer($this, index);
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    return tmp;
+  }
+  return list.u(index / ensureNotNull($this.b35_1).length | 0);
+}
+function throwSingleBuffer($this, index) {
+  if ($this.d35_1)
+    throw IllegalStateException_init_$Create$('Buffer is already released');
+  throw IndexOutOfBoundsException_init_$Create$('' + index + ' is not in range [0; ' + currentPosition($this) + ')');
+}
+function nonFullBuffer($this) {
+  return $this.e35_1 === 0 ? appendNewArray($this) : ensureNotNull($this.b35_1);
+}
+function appendNewArray($this) {
+  var newBuffer = $this.z34_1.n1z();
+  var existing = $this.b35_1;
+  $this.b35_1 = newBuffer;
+  $this.e35_1 = newBuffer.length;
+  $this.d35_1 = false;
+  if (!(existing == null)) {
+    var tmp0_elvis_lhs = $this.a35_1;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      // Inline function 'kotlin.also' call
+      var this_0 = ArrayList_init_$Create$();
+      $this.a35_1 = this_0;
+      this_0.k(existing);
+      tmp = this_0;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var list = tmp;
+    list.k(newBuffer);
+  }
+  return newBuffer;
+}
+function rangeEqualsImpl($this, start, other, otherStart, length) {
+  var inductionVariable = 0;
+  if (inductionVariable < length)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      if (!(getImpl($this, start + i | 0) === charSequenceGet(other, otherStart + i | 0)))
+        return false;
+    }
+     while (inductionVariable < length);
+  return true;
+}
+function hashCodeImpl($this, start, end) {
+  var hc = 0;
+  var inductionVariable = start;
+  if (inductionVariable < end)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp = imul(31, hc);
+      // Inline function 'kotlin.code' call
+      var this_0 = getImpl($this, i);
+      hc = tmp + Char__toInt_impl_vasixd(this_0) | 0;
+    }
+     while (inductionVariable < end);
+  return hc;
+}
+function currentPosition($this) {
+  return ensureNotNull($this.b35_1).length - $this.e35_1 | 0;
+}
+function CharArrayBuilder(pool) {
+  pool = pool === VOID ? get_CharArrayPool() : pool;
+  this.z34_1 = pool;
+  this.a35_1 = null;
+  this.b35_1 = null;
+  this.c35_1 = null;
+  this.d35_1 = false;
+  this.e35_1 = 0;
+  this.f35_1 = 0;
+}
+protoOf(CharArrayBuilder).a = function () {
+  return this.f35_1;
+};
+protoOf(CharArrayBuilder).b = function (index) {
+  // Inline function 'kotlin.require' call
+  if (!(index >= 0)) {
+    var message = 'index is negative: ' + index;
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(index < this.f35_1)) {
+    var message_0 = 'index ' + index + ' is not in range [0, ' + this.f35_1 + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  return getImpl(this, index);
+};
+protoOf(CharArrayBuilder).c = function (startIndex, endIndex) {
+  // Inline function 'kotlin.require' call
+  if (!(startIndex <= endIndex)) {
+    var message = 'startIndex (' + startIndex + ') should be less or equal to endIndex (' + endIndex + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(startIndex >= 0)) {
+    var message_0 = 'startIndex is negative: ' + startIndex;
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(endIndex <= this.f35_1)) {
+    var message_1 = 'endIndex (' + endIndex + ') is greater than length (' + this.f35_1 + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_1));
+  }
+  return new SubSequenceImpl(this, startIndex, endIndex);
+};
+protoOf(CharArrayBuilder).toString = function () {
+  var tmp0_elvis_lhs = this.c35_1;
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlin.also' call
+    var this_0 = toString(copy(this, 0, this.f35_1));
+    this.c35_1 = this_0;
+    tmp = this_0;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+};
+protoOf(CharArrayBuilder).equals = function (other) {
+  if (!(!(other == null) ? isCharSequence(other) : false))
+    return false;
+  if (!(this.f35_1 === charSequenceLength(other)))
+    return false;
+  return rangeEqualsImpl(this, 0, other, 0, this.f35_1);
+};
+protoOf(CharArrayBuilder).hashCode = function () {
+  var tmp0_safe_receiver = this.c35_1;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : getStringHashCode(tmp0_safe_receiver);
+  return tmp1_elvis_lhs == null ? hashCodeImpl(this, 0, this.f35_1) : tmp1_elvis_lhs;
+};
+protoOf(CharArrayBuilder).r8 = function (value) {
+  nonFullBuffer(this)[ensureNotNull(this.b35_1).length - this.e35_1 | 0] = value;
+  this.c35_1 = null;
+  this.e35_1 = this.e35_1 - 1 | 0;
+  this.f35_1 = this.f35_1 + 1 | 0;
+  return this;
+};
+protoOf(CharArrayBuilder).hd = function (value, startIndex, endIndex) {
+  if (value == null)
+    return this;
+  var current = startIndex;
+  while (current < endIndex) {
+    var buffer = nonFullBuffer(this);
+    var offset = buffer.length - this.e35_1 | 0;
+    var tmp0 = endIndex - current | 0;
+    // Inline function 'kotlin.math.min' call
+    var b = this.e35_1;
+    var bytesToCopy = Math.min(tmp0, b);
+    var inductionVariable = 0;
+    if (inductionVariable < bytesToCopy)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        buffer[offset + i | 0] = charSequenceGet(value, current + i | 0);
+      }
+       while (inductionVariable < bytesToCopy);
+    current = current + bytesToCopy | 0;
+    this.e35_1 = this.e35_1 - bytesToCopy | 0;
+  }
+  this.c35_1 = null;
+  this.f35_1 = this.f35_1 + (endIndex - startIndex | 0) | 0;
+  return this;
+};
+protoOf(CharArrayBuilder).o = function (value) {
+  if (value == null)
+    return this;
+  return this.hd(value, 0, charSequenceLength(value));
+};
+protoOf(CharArrayBuilder).z1g = function () {
+  var list = this.a35_1;
+  if (!(list == null)) {
+    this.b35_1 = null;
+    var inductionVariable = 0;
+    var last = list.s();
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        this.z34_1.o1z(list.u(i));
+      }
+       while (inductionVariable < last);
+  } else {
+    var tmp0_safe_receiver = this.b35_1;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      this.z34_1.o1z(tmp0_safe_receiver);
+    }
+    this.b35_1 = null;
+  }
+  this.d35_1 = true;
+  this.a35_1 = null;
+  this.c35_1 = null;
+  this.f35_1 = 0;
+  this.e35_1 = 0;
+};
+function get_CharArrayPool() {
+  _init_properties_CharArrayPool_kt__u4nq0d();
+  return CharArrayPool;
+}
+var CharArrayPool;
+function CharArrayPool$1() {
+  NoPoolImpl.call(this);
+}
+protoOf(CharArrayPool$1).n1z = function () {
+  return charArray(2048);
+};
+function CharArrayPool$2() {
+  DefaultPool.call(this, 4096);
+}
+protoOf(CharArrayPool$2).g1z = function () {
+  return charArray(2048);
+};
+var properties_initialized_CharArrayPool_kt_aq0u0f;
+function _init_properties_CharArrayPool_kt__u4nq0d() {
+  if (!properties_initialized_CharArrayPool_kt_aq0u0f) {
+    properties_initialized_CharArrayPool_kt_aq0u0f = true;
+    var tmp;
+    if (isPoolingDisabled()) {
+      tmp = new CharArrayPool$1();
+    } else {
+      tmp = new CharArrayPool$2();
+    }
+    CharArrayPool = tmp;
+  }
+}
+var DefaultHttpMethods;
+var HexTable;
+var HexLetterTable;
+function parseDecLong(_this__u8e3s4) {
+  _init_properties_Chars_kt__d3i39x();
+  var length = charSequenceLength(_this__u8e3s4);
+  if (length > 19) {
+    numberFormatException(_this__u8e3s4);
+  }
+  if (length === 19)
+    return parseDecLongWithCheck(_this__u8e3s4);
+  var result = new Long(0, 0);
+  var inductionVariable = 0;
+  if (inductionVariable < length)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.code' call
+      var this_0 = charSequenceGet(_this__u8e3s4, i);
+      var tmp$ret$0 = Char__toInt_impl_vasixd(this_0);
+      var digit = toLong(tmp$ret$0).c3(new Long(48, 0));
+      if (digit.g1(new Long(0, 0)) < 0 || digit.g1(new Long(9, 0)) > 0) {
+        numberFormatException_0(_this__u8e3s4, i);
+      }
+      result = result.l3(3).b3(result.l3(1)).b3(digit);
+    }
+     while (inductionVariable < length);
+  return result;
+}
+function hashCodeLowerCase(_this__u8e3s4, start, end) {
+  start = start === VOID ? 0 : start;
+  end = end === VOID ? charSequenceLength(_this__u8e3s4) : end;
+  _init_properties_Chars_kt__d3i39x();
+  var hashCode = 0;
+  var inductionVariable = start;
+  if (inductionVariable < end)
+    do {
+      var pos = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.code' call
+      var this_0 = charSequenceGet(_this__u8e3s4, pos);
+      // Inline function 'io.ktor.http.cio.internals.toLowerCase' call
+      var this_1 = Char__toInt_impl_vasixd(this_0);
+      var tmp;
+      // Inline function 'kotlin.code' call
+      var this_2 = _Char___init__impl__6a9atx(65);
+      var containsLower = Char__toInt_impl_vasixd(this_2);
+      var tmp_0;
+      // Inline function 'kotlin.code' call
+      var this_3 = _Char___init__impl__6a9atx(90);
+      if (this_1 <= Char__toInt_impl_vasixd(this_3)) {
+        tmp_0 = containsLower <= this_1;
+      } else {
+        tmp_0 = false;
+      }
+      if (tmp_0) {
+        // Inline function 'kotlin.code' call
+        var this_4 = _Char___init__impl__6a9atx(97);
+        var tmp_1 = Char__toInt_impl_vasixd(this_4);
+        // Inline function 'kotlin.code' call
+        var this_5 = _Char___init__impl__6a9atx(65);
+        tmp = tmp_1 + (this_1 - Char__toInt_impl_vasixd(this_5) | 0) | 0;
+      } else {
+        tmp = this_1;
+      }
+      var v = tmp;
+      hashCode = imul(31, hashCode) + v | 0;
+    }
+     while (inductionVariable < end);
+  return hashCode;
+}
+function numberFormatException(cs) {
+  _init_properties_Chars_kt__d3i39x();
+  throw NumberFormatException_init_$Create$('Invalid number ' + toString(cs) + ': too large for Long type');
+}
+function parseDecLongWithCheck(_this__u8e3s4) {
+  _init_properties_Chars_kt__d3i39x();
+  var result = new Long(0, 0);
+  var inductionVariable = 0;
+  var last = charSequenceLength(_this__u8e3s4) - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.code' call
+      var this_0 = charSequenceGet(_this__u8e3s4, i);
+      var tmp$ret$0 = Char__toInt_impl_vasixd(this_0);
+      var digit = toLong(tmp$ret$0).c3(new Long(48, 0));
+      if (digit.g1(new Long(0, 0)) < 0 || digit.g1(new Long(9, 0)) > 0) {
+        numberFormatException_0(_this__u8e3s4, i);
+      }
+      result = result.l3(3).b3(result.l3(1)).b3(digit);
+      if (result.g1(new Long(0, 0)) < 0) {
+        numberFormatException(_this__u8e3s4);
+      }
+    }
+     while (inductionVariable <= last);
+  return result;
+}
+function numberFormatException_0(cs, idx) {
+  _init_properties_Chars_kt__d3i39x();
+  throw NumberFormatException_init_$Create$('Invalid number: ' + toString(cs) + ', wrong digit: ' + toString_1(charSequenceGet(cs, idx)) + ' at position ' + idx);
+}
+function DefaultHttpMethods$lambda(it) {
+  _init_properties_Chars_kt__d3i39x();
+  return it.a2z_1.length;
+}
+function DefaultHttpMethods$lambda_0(m, idx) {
+  _init_properties_Chars_kt__d3i39x();
+  return new Char(charSequenceGet(m.a2z_1, idx));
+}
+var properties_initialized_Chars_kt_phjfhp;
+function _init_properties_Chars_kt__d3i39x() {
+  if (!properties_initialized_Chars_kt_phjfhp) {
+    properties_initialized_Chars_kt_phjfhp = true;
+    var tmp = Companion_instance;
+    var tmp_0 = Companion_getInstance().z2y_1;
+    var tmp_1 = DefaultHttpMethods$lambda;
+    DefaultHttpMethods = tmp.n39(tmp_0, tmp_1, DefaultHttpMethods$lambda_0);
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = numberRangeToNumber(0, 255);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var inductionVariable = this_0.h1_1;
+    var last = this_0.i1_1;
+    if (inductionVariable <= last)
+      do {
+        var item = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var v = item;
+        var tmp_2;
+        if (48 <= v ? v <= 57 : false) {
+          tmp_2 = numberToLong(v).c3(new Long(48, 0));
+        } else {
+          var tmp_3;
+          var tmp_4 = toLong(v);
+          // Inline function 'kotlin.code' call
+          var this_1 = _Char___init__impl__6a9atx(97);
+          var tmp$ret$0 = Char__toInt_impl_vasixd(this_1);
+          if (tmp_4.g1(toLong(tmp$ret$0)) >= 0) {
+            var tmp_5 = toLong(v);
+            // Inline function 'kotlin.code' call
+            var this_2 = _Char___init__impl__6a9atx(102);
+            var tmp$ret$1 = Char__toInt_impl_vasixd(this_2);
+            tmp_3 = tmp_5.g1(toLong(tmp$ret$1)) <= 0;
+          } else {
+            tmp_3 = false;
+          }
+          if (tmp_3) {
+            // Inline function 'kotlin.code' call
+            var this_3 = _Char___init__impl__6a9atx(97);
+            var tmp$ret$2 = Char__toInt_impl_vasixd(this_3);
+            // Inline function 'kotlin.Long.plus' call
+            tmp_2 = numberToLong(v).c3(toLong(tmp$ret$2)).b3(toLong(10));
+          } else {
+            var tmp_6;
+            var tmp_7 = toLong(v);
+            // Inline function 'kotlin.code' call
+            var this_4 = _Char___init__impl__6a9atx(65);
+            var tmp$ret$4 = Char__toInt_impl_vasixd(this_4);
+            if (tmp_7.g1(toLong(tmp$ret$4)) >= 0) {
+              var tmp_8 = toLong(v);
+              // Inline function 'kotlin.code' call
+              var this_5 = _Char___init__impl__6a9atx(70);
+              var tmp$ret$5 = Char__toInt_impl_vasixd(this_5);
+              tmp_6 = tmp_8.g1(toLong(tmp$ret$5)) <= 0;
+            } else {
+              tmp_6 = false;
+            }
+            if (tmp_6) {
+              // Inline function 'kotlin.code' call
+              var this_6 = _Char___init__impl__6a9atx(65);
+              var tmp$ret$6 = Char__toInt_impl_vasixd(this_6);
+              // Inline function 'kotlin.Long.plus' call
+              tmp_2 = numberToLong(v).c3(toLong(tmp$ret$6)).b3(toLong(10));
+            } else {
+              tmp_2 = new Long(-1, -1);
+            }
+          }
+        }
+        var tmp$ret$8 = tmp_2;
+        destination.k(tmp$ret$8);
+      }
+       while (!(item === last));
+    HexTable = toLongArray(destination);
+    // Inline function 'kotlin.collections.map' call
+    var this_7 = numberRangeToNumber(0, 15);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_7, 10));
+    var inductionVariable_0 = this_7.h1_1;
+    var last_0 = this_7.i1_1;
+    if (inductionVariable_0 <= last_0)
+      do {
+        var item_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        var it = item_0;
+        var tmp_9;
+        if (it < 10) {
+          tmp_9 = toByte(48 + it | 0);
+        } else {
+          // Inline function 'kotlin.code' call
+          var this_8 = Char__minus_impl_a2frrh(Char__plus_impl_qi7pgj(_Char___init__impl__6a9atx(97), it), 10);
+          var tmp$ret$0_0 = Char__toInt_impl_vasixd(this_8);
+          tmp_9 = toByte(tmp$ret$0_0);
+        }
+        var tmp$ret$1_0 = tmp_9;
+        destination_0.k(tmp$ret$1_0);
+      }
+       while (!(item_0 === last_0));
+    HexLetterTable = toByteArray(destination_0);
+  }
+}
+function UnsupportedMediaTypeExceptionCIO(message) {
+  IOException_init_$Init$(message, this);
+  captureStack(this, UnsupportedMediaTypeExceptionCIO);
+}
+function MutableRange(start, end) {
+  this.x35_1 = start;
+  this.y35_1 = end;
+}
+protoOf(MutableRange).toString = function () {
+  return 'MutableRange(start=' + this.x35_1 + ', end=' + this.y35_1 + ')';
+};
+function skipSpacesAndHorizontalTabs(text, start, end) {
+  var index = start;
+  $l$loop: while (index < end) {
+    var ch = text.b(index);
+    if (!isWhitespace(ch) && !(ch === _Char___init__impl__6a9atx(9)))
+      break $l$loop;
+    index = index + 1 | 0;
+  }
+  return index;
+}
+function isPoolingDisabled() {
+  return false;
+}
+//region block: init
+Companion_instance = new Companion();
+//endregion
+//region block: exports
+export {
+  CIOMultipartDataBase as CIOMultipartDataBase3o5u8w437tq5s,
+};
+//endregion
+
+//# sourceMappingURL=ktor-ktor-http-ktor-http-cio.mjs.map