git-digger 1.5.39 → 1.5.43

package/kotlin/kotlinx-serialization-kotlinx-serialization-core.mjs

@@ -0,0 +1,3640 @@
+import {
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  VOID7hggqo3abtya as VOID,
+  StringCompanionObject_instance2iflbktk67pca as StringCompanionObject_instance,
+  Unit_instance14hm69wy3kr8u as Unit_instance,
+  emptyList1g2z5xcrvp2zy as emptyList,
+  LazyThreadSafetyMode_PUBLICATION_getInstance2l411fkf5jrbp as LazyThreadSafetyMode_PUBLICATION_getInstance,
+  lazy1261dae0bgscp as lazy,
+  toString1pkumu07cwy4m as toString,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  getKClassFromExpression3vpejubogshaw as getKClassFromExpression,
+  KProperty1ca4yb4wlo496 as KProperty1,
+  getPropertyCallableRef1ajb9in178r5r as getPropertyCallableRef,
+  captureStack1fzi4aczwc4hg as captureStack,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  ArrayList3it5z8td81qkl as ArrayList,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  KClass1cc9rfeybg8hs as KClass,
+  isInterface3d6p8outrmvmk as isInterface,
+  Triple1vhi3d0dgpnjb as Triple,
+  getKClass1s3j9wy1cofik as getKClass,
+  Paire9pteg33gng7 as Pair,
+  Entry2xmjmyutzoq3p as Entry,
+  KtMap140uvy3s5zad8 as KtMap,
+  KtMutableMap1kqeifoi36kpz as KtMutableMap,
+  LinkedHashMap1zhqxkxv3xnkl as LinkedHashMap,
+  HashMap1a0ld5kgwhmhv as HashMap,
+  KtSetjrjc7fhfd6b9 as KtSet,
+  KtMutableSetwuwn7k5m570a as KtMutableSet,
+  LinkedHashSet2tkztfx86kyx2 as LinkedHashSet,
+  HashSet2dzve9y63nf0v as HashSet,
+  Collection1k04j3hzsbod0 as Collection,
+  KtList3hktaavzmj137 as KtList,
+  KtMutableList1beimitadwkna as KtMutableList,
+  copyToArray2j022khrow2yi as copyToArray,
+  _Result___get_value__impl__bjfvqgbxrwpgk5sesh as _Result___get_value__impl__bjfvqg,
+  _Result___get_isFailure__impl__jpiriv2jp2gwqhnirp8 as _Result___get_isFailure__impl__jpiriv,
+  Result3t1vadv16kmzk as Result,
+  ensureNotNull1e947j3ixpazm as ensureNotNull,
+  equals2au1ep9vhcato as equals,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  isBlank1dvkhjjvox3p0 as isBlank,
+  toList383f556t1dixk as toList,
+  toHashSet1qrcsl3g8ugc8 as toHashSet,
+  toBooleanArray2u3qw7fjwsmuh as toBooleanArray,
+  withIndex3s8q7w1g0hyfn as withIndex,
+  to2cs3ny02qtbcb as to,
+  toMap1vec9topfei08 as toMap,
+  lazy2hsh8ze7j6ikd as lazy_0,
+  contentEqualsaf55p28mnw74 as contentEquals,
+  until1jbpn0z3f8lbg as until,
+  joinToString1cxrrlmo0chqs as joinToString,
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  createThis2j2avj17cvnv2 as createThis,
+  Char19o2r8palgjof as Char,
+  Duration__toIsoString_impl_9h6wsm2kf5is6ue36 as Duration__toIsoString_impl_9h6wsm,
+  Duration5ynfiptaqcrg as Duration,
+  Uuid1zxgztb7abqxx as Uuid,
+  hashCodeq5arwsb9dgti as hashCode,
+  IllegalStateExceptionkoljg5n0nrlr as IllegalStateException,
+  isArray1hxjqtqy632bc as isArray,
+  arrayIterator3lgwvgteckzhv as arrayIterator,
+  toString30pk9tzaqopn as toString_0,
+  KTypeParameter1s8efufd4mbj5 as KTypeParameter,
+  contentHashCode2i020q5tbeh2s as contentHashCode,
+  fillArrayVali8eppxapiek4 as fillArrayVal,
+  booleanArray2jdug9b51huk7 as booleanArray,
+  emptyMapr06gerzljqtm as emptyMap,
+  Companion_getInstance36uki9uc3fsps as Companion_getInstance,
+  isCharArray21auq5hbrg68m as isCharArray,
+  DoubleCompanionObject_instanceciblawwgcicl as DoubleCompanionObject_instance,
+  isDoubleArray1wyh4nyf7pjxn as isDoubleArray,
+  FloatCompanionObject_instance3pcatcooqioqk as FloatCompanionObject_instance,
+  isFloatArrayjjscnqphw92j as isFloatArray,
+  Companion_getInstance2vaobcepcnf7z as Companion_getInstance_0,
+  isLongArray2fdt3z7yu3ef as isLongArray,
+  Companion_getInstance1mvktysd7mugj as Companion_getInstance_1,
+  _ULongArray___get_size__impl__ju6dtr5v7zdjz7p45k as _ULongArray___get_size__impl__ju6dtr,
+  ULongArray3nd0d80mdwjj8 as ULongArray,
+  ULongArray__get_impl_pr71q92g1kdq5mz2hdv as ULongArray__get_impl_pr71q9,
+  _ULong___get_data__impl__fggpzb77rs34yu2akv as _ULong___get_data__impl__fggpzb,
+  IntCompanionObject_instance1a9qdfxmssxfv as IntCompanionObject_instance,
+  isIntArrayeijsubfngq38 as isIntArray,
+  Companion_getInstance13gx1njt9e9uj as Companion_getInstance_2,
+  _UIntArray___get_size__impl__r6l8ci3qgksw2fv2zbg as _UIntArray___get_size__impl__r6l8ci,
+  UIntArrayrp6cv44n5v4y as UIntArray,
+  UIntArray__get_impl_gp5kzae60hwt0gkwo9 as UIntArray__get_impl_gp5kza,
+  _UInt___get_data__impl__f0vqqw1wfqgh301wggv as _UInt___get_data__impl__f0vqqw,
+  ShortCompanionObject_instance2jwrskkmak9m1 as ShortCompanionObject_instance,
+  isShortArraywz30zxwtqi8h as isShortArray,
+  Companion_getInstance12z43b8xpc5ug as Companion_getInstance_3,
+  _UShortArray___get_size__impl__jqto1b36yuj0vpbb4fa as _UShortArray___get_size__impl__jqto1b,
+  UShortArray11avpmknxdgvv as UShortArray,
+  UShortArray__get_impl_fnbhmx1y5d8996erjf3 as UShortArray__get_impl_fnbhmx,
+  _UShort___get_data__impl__g02453buibbzrpmeid as _UShort___get_data__impl__g0245,
+  ByteCompanionObject_instance2n6kdzwwtagd9 as ByteCompanionObject_instance,
+  isByteArray4nnzfn1x4o3w as isByteArray,
+  Companion_getInstance2ojplvvf2x2v2 as Companion_getInstance_4,
+  _UByteArray___get_size__impl__h6pkdv15deqqx7xzfdr as _UByteArray___get_size__impl__h6pkdv,
+  UByteArray2qu4d6gwssdf9 as UByteArray,
+  UByteArray__get_impl_t5f3hv1encpe8trq9zx as UByteArray__get_impl_t5f3hv,
+  _UByte___get_data__impl__jof9qr1jhbnu489etgz as _UByte___get_data__impl__jof9qr,
+  BooleanCompanionObject_instance2vl2vvm82he0e as BooleanCompanionObject_instance,
+  isBooleanArray35llghle4c6w1 as isBooleanArray,
+  Long2qws0ah9gnpki as Long,
+  Unitkvevlwgzwiuc as Unit,
+  trimIndent1qytc1wvt8suh as trimIndent,
+  ULong3f9k7s38t3rfp as ULong,
+  UInt1hthisrv6cndi as UInt,
+  UShort26xnqty60t7le as UShort,
+  UBytep4j7r1t64gz1 as UByte,
+  PrimitiveClasses_getInstance2khhb8173vcfl as PrimitiveClasses_getInstance,
+  Companion_getInstance1mc3g3aij23my as Companion_getInstance_5,
+  Companion_getInstance31zkbd7u6qrr4 as Companion_getInstance_6,
+  mapOf1xd03cq9cnmy8 as mapOf,
+  get_js1ale1wr4fbvs0 as get_js,
+  findAssociatedObject1kb88g16k1goa as findAssociatedObject,
+  IndexOutOfBoundsException1qfr429iumro0 as IndexOutOfBoundsException,
+  get_indicesc04v40g017hw as get_indices,
+  Companion_instance1et3290wko23u as Companion_instance,
+  _Result___init__impl__xyqfz8oelep8i0cbta as _Result___init__impl__xyqfz8,
+  createFailure8paxfkfa5dc7 as createFailure,
+} from './kotlin-kotlin-stdlib.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+class SerializationStrategy {}
+class KSerializer {}
+class AbstractPolymorphicSerializer {
+  xo(encoder, value) {
+    var actualSerializer = findPolymorphicSerializer(this, encoder, value);
+    // Inline function 'kotlinx.serialization.encoding.encodeStructure' call
+    var descriptor = this.io();
+    var composite = encoder.rq(descriptor);
+    // Inline function 'kotlinx.serialization.internal.AbstractPolymorphicSerializer.serialize.<anonymous>' call
+    composite.or(this.io(), 0, actualSerializer.io().pp());
+    var tmp = this.io();
+    // Inline function 'kotlinx.serialization.internal.cast' call
+    var tmp$ret$0 = isInterface(actualSerializer, SerializationStrategy) ? actualSerializer : THROW_CCE();
+    composite.qr(tmp, 1, tmp$ret$0, value);
+    composite.sq(descriptor);
+  }
+  jo(encoder, value) {
+    return this.xo(encoder, !(value == null) ? value : THROW_CCE());
+  }
+  yo(encoder, value) {
+    return encoder.ur().yr(this.wo(), value);
+  }
+}
+class PolymorphicSerializer extends AbstractPolymorphicSerializer {
+  constructor(baseClass) {
+    super();
+    this.to_1 = baseClass;
+    this.uo_1 = emptyList();
+    var tmp = this;
+    var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+    tmp.vo_1 = lazy(tmp_0, PolymorphicSerializer$descriptor$delegate$lambda(this));
+  }
+  wo() {
+    return this.to_1;
+  }
+  io() {
+    var tmp0 = this.vo_1;
+    // Inline function 'kotlin.getValue' call
+    descriptor$factory();
+    return tmp0.s1();
+  }
+  toString() {
+    return 'kotlinx.serialization.PolymorphicSerializer(baseClass: ' + toString(this.to_1) + ')';
+  }
+}
+class SealedClassSerializer extends AbstractPolymorphicSerializer {
+  io() {
+    var tmp0 = this.zo_1;
+    // Inline function 'kotlin.getValue' call
+    descriptor$factory_0();
+    return tmp0.s1();
+  }
+}
+class SerializationException extends IllegalArgumentException {
+  static ep() {
+    var $this = this.rc();
+    init_kotlinx_serialization_SerializationException($this);
+    return $this;
+  }
+  static fp(message) {
+    var $this = this.s(message);
+    init_kotlinx_serialization_SerializationException($this);
+    return $this;
+  }
+}
+class SerialDescriptor {}
+function get_isNullable() {
+  return false;
+}
+function get_isInline() {
+  return false;
+}
+function get_annotations() {
+  return emptyList();
+}
+class ContextDescriptor {
+  constructor(original, kClass) {
+    this.mp_1 = original;
+    this.np_1 = kClass;
+    this.op_1 = this.mp_1.pp() + '<' + this.np_1.ce() + '>';
+  }
+  pp() {
+    return this.op_1;
+  }
+  equals(other) {
+    var tmp0_elvis_lhs = other instanceof ContextDescriptor ? other : null;
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      return false;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var another = tmp;
+    return equals(this.mp_1, another.mp_1) && another.np_1.equals(this.np_1);
+  }
+  hashCode() {
+    var result = this.np_1.hashCode();
+    result = imul(31, result) + getStringHashCode(this.op_1) | 0;
+    return result;
+  }
+  toString() {
+    return 'ContextDescriptor(kClass: ' + toString(this.np_1) + ', original: ' + toString(this.mp_1) + ')';
+  }
+  qp() {
+    return this.mp_1.qp();
+  }
+  lp() {
+    return this.mp_1.lp();
+  }
+  rp() {
+    return this.mp_1.rp();
+  }
+  sp() {
+    return this.mp_1.sp();
+  }
+  tp() {
+    return this.mp_1.tp();
+  }
+  up(index) {
+    return this.mp_1.up(index);
+  }
+  vp(index) {
+    return this.mp_1.vp(index);
+  }
+}
+class elementDescriptors$1 {
+  constructor($this_elementDescriptors) {
+    this.aq_1 = $this_elementDescriptors;
+    this.zp_1 = $this_elementDescriptors.sp();
+  }
+  e1() {
+    return this.zp_1 > 0;
+  }
+  f1() {
+    var tmp = this.aq_1.sp();
+    var _unary__edvuaz = this.zp_1;
+    this.zp_1 = _unary__edvuaz - 1 | 0;
+    return this.aq_1.vp(tmp - _unary__edvuaz | 0);
+  }
+}
+class elementDescriptors$$inlined$Iterable$1 {
+  constructor($this_elementDescriptors) {
+    this.bq_1 = $this_elementDescriptors;
+  }
+  d1() {
+    // Inline function 'kotlinx.serialization.descriptors.<get-elementDescriptors>.<anonymous>' call
+    return new elementDescriptors$1(this.bq_1);
+  }
+}
+class ClassSerialDescriptorBuilder {
+  constructor(serialName) {
+    this.ko_1 = serialName;
+    this.lo_1 = false;
+    this.mo_1 = emptyList();
+    this.no_1 = ArrayList.n();
+    this.oo_1 = HashSet.g9();
+    this.po_1 = ArrayList.n();
+    this.qo_1 = ArrayList.n();
+    this.ro_1 = ArrayList.n();
+  }
+  cq(elementName, descriptor, annotations, isOptional) {
+    // Inline function 'kotlin.require' call
+    if (!this.oo_1.o(elementName)) {
+      // Inline function 'kotlinx.serialization.descriptors.ClassSerialDescriptorBuilder.element.<anonymous>' call
+      var message = "Element with name '" + elementName + "' is already registered in " + this.ko_1;
+      throw IllegalArgumentException.s(toString(message));
+    }
+    // Inline function 'kotlin.collections.plusAssign' call
+    this.no_1.o(elementName);
+    // Inline function 'kotlin.collections.plusAssign' call
+    this.po_1.o(descriptor);
+    // Inline function 'kotlin.collections.plusAssign' call
+    this.qo_1.o(annotations);
+    // Inline function 'kotlin.collections.plusAssign' call
+    this.ro_1.o(isOptional);
+  }
+  so(elementName, descriptor, annotations, isOptional, $super) {
+    annotations = annotations === VOID ? emptyList() : annotations;
+    isOptional = isOptional === VOID ? false : isOptional;
+    var tmp;
+    if ($super === VOID) {
+      this.cq(elementName, descriptor, annotations, isOptional);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.cq.call(this, elementName, descriptor, annotations, isOptional);
+    }
+    return tmp;
+  }
+}
+class CachedNames {}
+class SerialDescriptorImpl {
+  constructor(serialName, kind, elementsCount, typeParameters, builder) {
+    this.dq_1 = serialName;
+    this.eq_1 = kind;
+    this.fq_1 = elementsCount;
+    this.gq_1 = builder.mo_1;
+    this.hq_1 = toHashSet(builder.no_1);
+    var tmp = this;
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_0 = builder.no_1;
+    tmp.iq_1 = copyToArray(this_0);
+    this.jq_1 = compactArray(builder.po_1);
+    var tmp_0 = this;
+    // Inline function 'kotlin.collections.toTypedArray' call
+    var this_1 = builder.qo_1;
+    tmp_0.kq_1 = copyToArray(this_1);
+    this.lq_1 = toBooleanArray(builder.ro_1);
+    var tmp_1 = this;
+    // Inline function 'kotlin.collections.map' call
+    var this_2 = withIndex(this.iq_1);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList.k1(collectionSizeOrDefault(this_2, 10));
+    var _iterator__ex2g4s = this_2.d1();
+    while (_iterator__ex2g4s.e1()) {
+      var item = _iterator__ex2g4s.f1();
+      // Inline function 'kotlinx.serialization.descriptors.SerialDescriptorImpl.name2Index.<anonymous>' call
+      var tmp$ret$2 = to(item.ri_1, item.qi_1);
+      destination.o(tmp$ret$2);
+    }
+    tmp_1.mq_1 = toMap(destination);
+    this.nq_1 = compactArray(typeParameters);
+    var tmp_2 = this;
+    tmp_2.oq_1 = lazy_0(SerialDescriptorImpl$_hashCode$delegate$lambda(this));
+  }
+  pp() {
+    return this.dq_1;
+  }
+  qp() {
+    return this.eq_1;
+  }
+  sp() {
+    return this.fq_1;
+  }
+  tp() {
+    return this.gq_1;
+  }
+  pq() {
+    return this.hq_1;
+  }
+  up(index) {
+    return getChecked(this.iq_1, index);
+  }
+  vp(index) {
+    return getChecked(this.jq_1, index);
+  }
+  equals(other) {
+    var tmp$ret$0;
+    $l$block_5: {
+      // Inline function 'kotlinx.serialization.internal.equalsImpl' call
+      if (this === other) {
+        tmp$ret$0 = true;
+        break $l$block_5;
+      }
+      if (!(other instanceof SerialDescriptorImpl)) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      if (!(this.pp() === other.pp())) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      // Inline function 'kotlinx.serialization.descriptors.SerialDescriptorImpl.equals.<anonymous>' call
+      if (!contentEquals(this.nq_1, other.nq_1)) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      if (!(this.sp() === other.sp())) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      var inductionVariable = 0;
+      var last = this.sp();
+      if (inductionVariable < last)
+        do {
+          var index = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          if (!(this.vp(index).pp() === other.vp(index).pp())) {
+            tmp$ret$0 = false;
+            break $l$block_5;
+          }
+          if (!equals(this.vp(index).qp(), other.vp(index).qp())) {
+            tmp$ret$0 = false;
+            break $l$block_5;
+          }
+        }
+         while (inductionVariable < last);
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  }
+  hashCode() {
+    return _get__hashCode__tgwhef(this);
+  }
+  toString() {
+    var tmp = until(0, this.fq_1);
+    var tmp_0 = this.dq_1 + '(';
+    return joinToString(tmp, ', ', tmp_0, ')', VOID, VOID, SerialDescriptorImpl$toString$lambda(this));
+  }
+}
+class SerialKind {
+  toString() {
+    return ensureNotNull(getKClassFromExpression(this).ce());
+  }
+  hashCode() {
+    return getStringHashCode(this.toString());
+  }
+}
+class ENUM extends SerialKind {
+  constructor() {
+    ENUM_instance = null;
+    super();
+    ENUM_instance = this;
+  }
+}
+class CONTEXTUAL extends SerialKind {
+  constructor() {
+    CONTEXTUAL_instance = null;
+    super();
+    CONTEXTUAL_instance = this;
+  }
+}
+class PolymorphicKind extends SerialKind {}
+class OPEN extends PolymorphicKind {
+  constructor() {
+    OPEN_instance = null;
+    super();
+    OPEN_instance = this;
+  }
+}
+class PrimitiveKind extends SerialKind {}
+class BOOLEAN extends PrimitiveKind {
+  constructor() {
+    BOOLEAN_instance = null;
+    super();
+    BOOLEAN_instance = this;
+  }
+}
+class BYTE extends PrimitiveKind {
+  constructor() {
+    BYTE_instance = null;
+    super();
+    BYTE_instance = this;
+  }
+}
+class CHAR extends PrimitiveKind {
+  constructor() {
+    CHAR_instance = null;
+    super();
+    CHAR_instance = this;
+  }
+}
+class SHORT extends PrimitiveKind {
+  constructor() {
+    SHORT_instance = null;
+    super();
+    SHORT_instance = this;
+  }
+}
+class INT extends PrimitiveKind {
+  constructor() {
+    INT_instance = null;
+    super();
+    INT_instance = this;
+  }
+}
+class LONG extends PrimitiveKind {
+  constructor() {
+    LONG_instance = null;
+    super();
+    LONG_instance = this;
+  }
+}
+class FLOAT extends PrimitiveKind {
+  constructor() {
+    FLOAT_instance = null;
+    super();
+    FLOAT_instance = this;
+  }
+}
+class DOUBLE extends PrimitiveKind {
+  constructor() {
+    DOUBLE_instance = null;
+    super();
+    DOUBLE_instance = this;
+  }
+}
+class STRING extends PrimitiveKind {
+  constructor() {
+    STRING_instance = null;
+    super();
+    STRING_instance = this;
+  }
+}
+class StructureKind extends SerialKind {}
+class CLASS extends StructureKind {
+  constructor() {
+    CLASS_instance = null;
+    super();
+    CLASS_instance = this;
+  }
+}
+class LIST extends StructureKind {
+  constructor() {
+    LIST_instance = null;
+    super();
+    LIST_instance = this;
+  }
+}
+class MAP extends StructureKind {
+  constructor() {
+    MAP_instance = null;
+    super();
+    MAP_instance = this;
+  }
+}
+class OBJECT extends StructureKind {
+  constructor() {
+    OBJECT_instance = null;
+    super();
+    OBJECT_instance = this;
+  }
+}
+class Encoder {}
+function encodeNotNullMark() {
+}
+function beginCollection(descriptor, collectionSize) {
+  return this.rq(descriptor);
+}
+function encodeSerializableValue(serializer, value) {
+  serializer.jo(this, value);
+}
+function encodeNullableSerializableValue(serializer, value) {
+  var isNullabilitySupported = serializer.io().lp();
+  if (isNullabilitySupported) {
+    return this.rr(isInterface(serializer, SerializationStrategy) ? serializer : THROW_CCE(), value);
+  }
+  if (value == null) {
+    this.vq();
+  } else {
+    this.vr();
+    this.rr(serializer, value);
+  }
+}
+class CompositeEncoder {}
+function shouldEncodeElementDefault(descriptor, index) {
+  return true;
+}
+class AbstractEncoder {
+  static qq() {
+    return createThis(this);
+  }
+  rq(descriptor) {
+    return this;
+  }
+  sq(descriptor) {
+  }
+  tq(descriptor, index) {
+    return true;
+  }
+  uq(value) {
+    throw SerializationException.fp('Non-serializable ' + toString(getKClassFromExpression(value)) + ' is not supported by ' + toString(getKClassFromExpression(this)) + ' encoder');
+  }
+  vq() {
+    throw SerializationException.fp("'null' is not supported by default");
+  }
+  wq(value) {
+    return this.uq(value);
+  }
+  xq(value) {
+    return this.uq(value);
+  }
+  yq(value) {
+    return this.uq(value);
+  }
+  zq(value) {
+    return this.uq(value);
+  }
+  ar(value) {
+    return this.uq(value);
+  }
+  br(value) {
+    return this.uq(value);
+  }
+  cr(value) {
+    return this.uq(value);
+  }
+  dr(value) {
+    return this.uq(new Char(value));
+  }
+  er(value) {
+    return this.uq(value);
+  }
+  fr(descriptor) {
+    return this;
+  }
+  gr(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.wq(value);
+    }
+  }
+  hr(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.xq(value);
+    }
+  }
+  ir(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.yq(value);
+    }
+  }
+  jr(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.zq(value);
+    }
+  }
+  kr(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.ar(value);
+    }
+  }
+  lr(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.br(value);
+    }
+  }
+  mr(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.cr(value);
+    }
+  }
+  nr(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.dr(value);
+    }
+  }
+  or(descriptor, index, value) {
+    if (this.tq(descriptor, index)) {
+      this.er(value);
+    }
+  }
+  pr(descriptor, index) {
+    return this.tq(descriptor, index) ? this.fr(descriptor.vp(index)) : NoOpEncoder_getInstance();
+  }
+  qr(descriptor, index, serializer, value) {
+    if (this.tq(descriptor, index)) {
+      this.rr(serializer, value);
+    }
+  }
+  sr(descriptor, index, serializer, value) {
+    if (this.tq(descriptor, index)) {
+      this.tr(serializer, value);
+    }
+  }
+}
+class NothingSerializer {
+  constructor() {
+    NothingSerializer_instance = this;
+    this.zr_1 = NothingSerialDescriptor_getInstance();
+  }
+  io() {
+    return this.zr_1;
+  }
+  as(encoder, value) {
+    throw SerializationException.fp("'kotlin.Nothing' cannot be serialized");
+  }
+  jo(encoder, value) {
+    var tmp;
+    if (false) {
+      tmp = value;
+    } else {
+      tmp = THROW_CCE();
+    }
+    return this.as(encoder, tmp);
+  }
+}
+class DurationSerializer {
+  constructor() {
+    DurationSerializer_instance = this;
+    this.bs_1 = new PrimitiveSerialDescriptor('kotlin.time.Duration', STRING_getInstance());
+  }
+  io() {
+    return this.bs_1;
+  }
+  cs(encoder, value) {
+    encoder.er(Duration__toIsoString_impl_9h6wsm(value));
+  }
+  jo(encoder, value) {
+    return this.cs(encoder, value instanceof Duration ? value.yl_1 : THROW_CCE());
+  }
+}
+class UuidSerializer {
+  constructor() {
+    UuidSerializer_instance = this;
+    this.ds_1 = new PrimitiveSerialDescriptor('kotlin.uuid.Uuid', STRING_getInstance());
+  }
+  io() {
+    return this.ds_1;
+  }
+  es(encoder, value) {
+    encoder.er(value.toString());
+  }
+  jo(encoder, value) {
+    return this.es(encoder, value instanceof Uuid ? value : THROW_CCE());
+  }
+}
+class ListLikeDescriptor {
+  constructor(elementDescriptor) {
+    this.hs_1 = elementDescriptor;
+    this.is_1 = 1;
+  }
+  qp() {
+    return LIST_getInstance();
+  }
+  sp() {
+    return this.is_1;
+  }
+  up(index) {
+    return index.toString();
+  }
+  vp(index) {
+    // Inline function 'kotlin.require' call
+    if (!(index >= 0)) {
+      // Inline function 'kotlinx.serialization.internal.ListLikeDescriptor.getElementDescriptor.<anonymous>' call
+      var message = 'Illegal index ' + index + ', ' + this.pp() + ' expects only non-negative indices';
+      throw IllegalArgumentException.s(toString(message));
+    }
+    return this.hs_1;
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof ListLikeDescriptor))
+      return false;
+    if (equals(this.hs_1, other.hs_1) && this.pp() === other.pp())
+      return true;
+    return false;
+  }
+  hashCode() {
+    return imul(hashCode(this.hs_1), 31) + getStringHashCode(this.pp()) | 0;
+  }
+  toString() {
+    return this.pp() + '(' + toString(this.hs_1) + ')';
+  }
+}
+class ArrayListClassDesc extends ListLikeDescriptor {
+  pp() {
+    return 'kotlin.collections.ArrayList';
+  }
+}
+class HashSetClassDesc extends ListLikeDescriptor {
+  pp() {
+    return 'kotlin.collections.HashSet';
+  }
+}
+class LinkedHashSetClassDesc extends ListLikeDescriptor {
+  pp() {
+    return 'kotlin.collections.LinkedHashSet';
+  }
+}
+class MapLikeDescriptor {
+  constructor(serialName, keyDescriptor, valueDescriptor) {
+    this.ns_1 = serialName;
+    this.os_1 = keyDescriptor;
+    this.ps_1 = valueDescriptor;
+    this.qs_1 = 2;
+  }
+  pp() {
+    return this.ns_1;
+  }
+  qp() {
+    return MAP_getInstance();
+  }
+  sp() {
+    return this.qs_1;
+  }
+  up(index) {
+    return index.toString();
+  }
+  vp(index) {
+    // Inline function 'kotlin.require' call
+    if (!(index >= 0)) {
+      // Inline function 'kotlinx.serialization.internal.MapLikeDescriptor.getElementDescriptor.<anonymous>' call
+      var message = 'Illegal index ' + index + ', ' + this.pp() + ' expects only non-negative indices';
+      throw IllegalArgumentException.s(toString(message));
+    }
+    var tmp;
+    switch (index % 2 | 0) {
+      case 0:
+        tmp = this.os_1;
+        break;
+      case 1:
+        tmp = this.ps_1;
+        break;
+      default:
+        var message_0 = 'Unreached';
+        throw IllegalStateException.e4(toString(message_0));
+    }
+    return tmp;
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof MapLikeDescriptor))
+      return false;
+    if (!(this.pp() === other.pp()))
+      return false;
+    if (!equals(this.os_1, other.os_1))
+      return false;
+    if (!equals(this.ps_1, other.ps_1))
+      return false;
+    return true;
+  }
+  hashCode() {
+    var result = getStringHashCode(this.pp());
+    result = imul(31, result) + hashCode(this.os_1) | 0;
+    result = imul(31, result) + hashCode(this.ps_1) | 0;
+    return result;
+  }
+  toString() {
+    return this.pp() + '(' + toString(this.os_1) + ', ' + toString(this.ps_1) + ')';
+  }
+}
+class HashMapClassDesc extends MapLikeDescriptor {
+  constructor(keyDesc, valueDesc) {
+    super('kotlin.collections.HashMap', keyDesc, valueDesc);
+  }
+}
+class LinkedHashMapClassDesc extends MapLikeDescriptor {
+  constructor(keyDesc, valueDesc) {
+    super('kotlin.collections.LinkedHashMap', keyDesc, valueDesc);
+  }
+}
+class ArrayClassDesc extends ListLikeDescriptor {
+  pp() {
+    return 'kotlin.Array';
+  }
+}
+class PrimitiveArrayDescriptor extends ListLikeDescriptor {
+  constructor(primitive) {
+    super(primitive);
+    this.vs_1 = primitive.pp() + 'Array';
+  }
+  pp() {
+    return this.vs_1;
+  }
+}
+class AbstractCollectionSerializer {}
+class CollectionLikeSerializer extends AbstractCollectionSerializer {
+  constructor(elementSerializer) {
+    super();
+    this.bt_1 = elementSerializer;
+  }
+  ct(encoder, value) {
+    var size = this.lt(value);
+    // Inline function 'kotlinx.serialization.encoding.encodeCollection' call
+    var descriptor = this.io();
+    var composite = encoder.wr(descriptor, size);
+    // Inline function 'kotlinx.serialization.internal.CollectionLikeSerializer.serialize.<anonymous>' call
+    var iterator = this.nt(value);
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        composite.qr(this.io(), index, this.bt_1, iterator.f1());
+      }
+       while (inductionVariable < size);
+    composite.sq(descriptor);
+  }
+  jo(encoder, value) {
+    return this.ct(encoder, (value == null ? true : !(value == null)) ? value : THROW_CCE());
+  }
+}
+class CollectionSerializer extends CollectionLikeSerializer {
+  zs(_this__u8e3s4) {
+    return _this__u8e3s4.i1();
+  }
+  lt(_this__u8e3s4) {
+    return this.zs((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, Collection) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  at(_this__u8e3s4) {
+    return _this__u8e3s4.d1();
+  }
+  nt(_this__u8e3s4) {
+    return this.at((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, Collection) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+}
+class ArrayListSerializer extends CollectionSerializer {
+  constructor(element) {
+    super(element);
+    this.xs_1 = new ArrayListClassDesc(element.io());
+  }
+  io() {
+    return this.xs_1;
+  }
+}
+class HashSetSerializer extends CollectionSerializer {
+  constructor(eSerializer) {
+    super(eSerializer);
+    this.et_1 = new HashSetClassDesc(eSerializer.io());
+  }
+  io() {
+    return this.et_1;
+  }
+}
+class LinkedHashSetSerializer extends CollectionSerializer {
+  constructor(eSerializer) {
+    super(eSerializer);
+    this.gt_1 = new LinkedHashSetClassDesc(eSerializer.io());
+  }
+  io() {
+    return this.gt_1;
+  }
+}
+class MapLikeSerializer extends AbstractCollectionSerializer {
+  constructor(keySerializer, valueSerializer) {
+    super();
+    this.ot_1 = keySerializer;
+    this.pt_1 = valueSerializer;
+  }
+  ct(encoder, value) {
+    var size = this.lt(value);
+    // Inline function 'kotlinx.serialization.encoding.encodeCollection' call
+    var descriptor = this.io();
+    var composite = encoder.wr(descriptor, size);
+    // Inline function 'kotlinx.serialization.internal.MapLikeSerializer.serialize.<anonymous>' call
+    var iterator = this.nt(value);
+    var index = 0;
+    // Inline function 'kotlin.collections.forEach' call
+    // Inline function 'kotlin.collections.iterator' call
+    var _iterator__ex2g4s = iterator;
+    while (_iterator__ex2g4s.e1()) {
+      var element = _iterator__ex2g4s.f1();
+      // Inline function 'kotlinx.serialization.internal.MapLikeSerializer.serialize.<anonymous>.<anonymous>' call
+      // Inline function 'kotlin.collections.component1' call
+      var k = element.r1();
+      // Inline function 'kotlin.collections.component2' call
+      var v = element.s1();
+      var tmp = this.io();
+      var _unary__edvuaz = index;
+      index = _unary__edvuaz + 1 | 0;
+      composite.qr(tmp, _unary__edvuaz, this.ot_1, k);
+      var tmp_0 = this.io();
+      var _unary__edvuaz_0 = index;
+      index = _unary__edvuaz_0 + 1 | 0;
+      composite.qr(tmp_0, _unary__edvuaz_0, this.pt_1, v);
+    }
+    composite.sq(descriptor);
+  }
+  jo(encoder, value) {
+    return this.ct(encoder, (value == null ? true : !(value == null)) ? value : THROW_CCE());
+  }
+}
+class HashMapSerializer extends MapLikeSerializer {
+  constructor(kSerializer, vSerializer) {
+    super(kSerializer, vSerializer);
+    this.jt_1 = new HashMapClassDesc(kSerializer.io(), vSerializer.io());
+  }
+  io() {
+    return this.jt_1;
+  }
+  kt(_this__u8e3s4) {
+    return _this__u8e3s4.i1();
+  }
+  lt(_this__u8e3s4) {
+    return this.kt((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, KtMap) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  mt(_this__u8e3s4) {
+    // Inline function 'kotlin.collections.iterator' call
+    return _this__u8e3s4.q1().d1();
+  }
+  nt(_this__u8e3s4) {
+    return this.mt((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, KtMap) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+}
+class LinkedHashMapSerializer extends MapLikeSerializer {
+  constructor(kSerializer, vSerializer) {
+    super(kSerializer, vSerializer);
+    this.st_1 = new LinkedHashMapClassDesc(kSerializer.io(), vSerializer.io());
+  }
+  io() {
+    return this.st_1;
+  }
+  kt(_this__u8e3s4) {
+    return _this__u8e3s4.i1();
+  }
+  lt(_this__u8e3s4) {
+    return this.kt((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, KtMap) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  mt(_this__u8e3s4) {
+    // Inline function 'kotlin.collections.iterator' call
+    return _this__u8e3s4.q1().d1();
+  }
+  nt(_this__u8e3s4) {
+    return this.mt((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, KtMap) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+}
+class ReferenceArraySerializer extends CollectionLikeSerializer {
+  constructor(kClass, eSerializer) {
+    super(eSerializer);
+    this.ut_1 = kClass;
+    this.vt_1 = new ArrayClassDesc(eSerializer.io());
+  }
+  io() {
+    return this.vt_1;
+  }
+  wt(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.wt((!(_this__u8e3s4 == null) ? isArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  xt(_this__u8e3s4) {
+    return arrayIterator(_this__u8e3s4);
+  }
+  nt(_this__u8e3s4) {
+    return this.xt((!(_this__u8e3s4 == null) ? isArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+}
+class PrimitiveArraySerializer extends CollectionLikeSerializer {
+  constructor(primitiveSerializer) {
+    super(primitiveSerializer);
+    this.zt_1 = new PrimitiveArrayDescriptor(primitiveSerializer.io());
+  }
+  io() {
+    return this.zt_1;
+  }
+  au(_this__u8e3s4) {
+    var message = 'This method lead to boxing and must not be used, use writeContents instead';
+    throw IllegalStateException.e4(toString(message));
+  }
+  nt(_this__u8e3s4) {
+    return this.au((_this__u8e3s4 == null ? true : !(_this__u8e3s4 == null)) ? _this__u8e3s4 : THROW_CCE());
+  }
+  cu(encoder, value) {
+    var size = this.lt(value);
+    // Inline function 'kotlinx.serialization.encoding.encodeCollection' call
+    var descriptor = this.zt_1;
+    var composite = encoder.wr(descriptor, size);
+    // Inline function 'kotlinx.serialization.internal.PrimitiveArraySerializer.serialize.<anonymous>' call
+    this.bu(composite, value, size);
+    composite.sq(descriptor);
+  }
+  jo(encoder, value) {
+    return this.cu(encoder, (value == null ? true : !(value == null)) ? value : THROW_CCE());
+  }
+  ct(encoder, value) {
+    return this.cu(encoder, (value == null ? true : !(value == null)) ? value : THROW_CCE());
+  }
+}
+class PluginGeneratedSerialDescriptor {
+  constructor(serialName, generatedSerializer, elementsCount) {
+    generatedSerializer = generatedSerializer === VOID ? null : generatedSerializer;
+    this.qu_1 = serialName;
+    this.ru_1 = generatedSerializer;
+    this.su_1 = elementsCount;
+    this.tu_1 = -1;
+    var tmp = this;
+    var tmp_0 = 0;
+    var tmp_1 = this.su_1;
+    // Inline function 'kotlin.arrayOfNulls' call
+    var tmp_2 = fillArrayVal(Array(tmp_1), null);
+    while (tmp_0 < tmp_1) {
+      tmp_2[tmp_0] = '[UNINITIALIZED]';
+      tmp_0 = tmp_0 + 1 | 0;
+    }
+    tmp.uu_1 = tmp_2;
+    var tmp_3 = this;
+    // Inline function 'kotlin.arrayOfNulls' call
+    var size = this.su_1;
+    tmp_3.vu_1 = fillArrayVal(Array(size), null);
+    this.wu_1 = null;
+    this.xu_1 = booleanArray(this.su_1);
+    this.yu_1 = emptyMap();
+    var tmp_4 = this;
+    var tmp_5 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+    tmp_4.zu_1 = lazy(tmp_5, PluginGeneratedSerialDescriptor$childSerializers$delegate$lambda(this));
+    var tmp_6 = this;
+    var tmp_7 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+    tmp_6.av_1 = lazy(tmp_7, PluginGeneratedSerialDescriptor$typeParameterDescriptors$delegate$lambda(this));
+    var tmp_8 = this;
+    var tmp_9 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+    tmp_8.bv_1 = lazy(tmp_9, PluginGeneratedSerialDescriptor$_hashCode$delegate$lambda(this));
+  }
+  pp() {
+    return this.qu_1;
+  }
+  sp() {
+    return this.su_1;
+  }
+  qp() {
+    return CLASS_getInstance();
+  }
+  tp() {
+    var tmp0_elvis_lhs = this.wu_1;
+    return tmp0_elvis_lhs == null ? emptyList() : tmp0_elvis_lhs;
+  }
+  pq() {
+    return this.yu_1.q2();
+  }
+  cv() {
+    var tmp0 = this.av_1;
+    // Inline function 'kotlin.getValue' call
+    typeParameterDescriptors$factory();
+    return tmp0.s1();
+  }
+  dv(name, isOptional) {
+    this.tu_1 = this.tu_1 + 1 | 0;
+    this.uu_1[this.tu_1] = name;
+    this.xu_1[this.tu_1] = isOptional;
+    this.vu_1[this.tu_1] = null;
+    if (this.tu_1 === (this.su_1 - 1 | 0)) {
+      this.yu_1 = buildIndices(this);
+    }
+  }
+  vp(index) {
+    return getChecked(_get_childSerializers__7vnyfa(this), index).io();
+  }
+  up(index) {
+    return getChecked(this.uu_1, index);
+  }
+  equals(other) {
+    var tmp$ret$0;
+    $l$block_5: {
+      // Inline function 'kotlinx.serialization.internal.equalsImpl' call
+      if (this === other) {
+        tmp$ret$0 = true;
+        break $l$block_5;
+      }
+      if (!(other instanceof PluginGeneratedSerialDescriptor)) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      if (!(this.pp() === other.pp())) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      // Inline function 'kotlinx.serialization.internal.PluginGeneratedSerialDescriptor.equals.<anonymous>' call
+      if (!contentEquals(this.cv(), other.cv())) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      if (!(this.sp() === other.sp())) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      var inductionVariable = 0;
+      var last = this.sp();
+      if (inductionVariable < last)
+        do {
+          var index = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          if (!(this.vp(index).pp() === other.vp(index).pp())) {
+            tmp$ret$0 = false;
+            break $l$block_5;
+          }
+          if (!equals(this.vp(index).qp(), other.vp(index).qp())) {
+            tmp$ret$0 = false;
+            break $l$block_5;
+          }
+        }
+         while (inductionVariable < last);
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  }
+  hashCode() {
+    return _get__hashCode__tgwhef_0(this);
+  }
+  toString() {
+    var tmp = until(0, this.su_1);
+    var tmp_0 = this.pp() + '(';
+    return joinToString(tmp, ', ', tmp_0, ')', VOID, VOID, PluginGeneratedSerialDescriptor$toString$lambda(this));
+  }
+}
+class InlineClassDescriptor extends PluginGeneratedSerialDescriptor {
+  constructor(name, generatedSerializer) {
+    super(name, generatedSerializer, 1);
+    this.pu_1 = true;
+  }
+  rp() {
+    return this.pu_1;
+  }
+  hashCode() {
+    return imul(super.hashCode(), 31);
+  }
+  equals(other) {
+    var tmp$ret$0;
+    $l$block_5: {
+      // Inline function 'kotlinx.serialization.internal.equalsImpl' call
+      if (this === other) {
+        tmp$ret$0 = true;
+        break $l$block_5;
+      }
+      if (!(other instanceof InlineClassDescriptor)) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      if (!(this.pp() === other.pp())) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      // Inline function 'kotlinx.serialization.internal.InlineClassDescriptor.equals.<anonymous>' call
+      if (!(other.pu_1 && contentEquals(this.cv(), other.cv()))) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      if (!(this.sp() === other.sp())) {
+        tmp$ret$0 = false;
+        break $l$block_5;
+      }
+      var inductionVariable = 0;
+      var last = this.sp();
+      if (inductionVariable < last)
+        do {
+          var index = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          if (!(this.vp(index).pp() === other.vp(index).pp())) {
+            tmp$ret$0 = false;
+            break $l$block_5;
+          }
+          if (!equals(this.vp(index).qp(), other.vp(index).qp())) {
+            tmp$ret$0 = false;
+            break $l$block_5;
+          }
+        }
+         while (inductionVariable < last);
+      tmp$ret$0 = true;
+    }
+    return tmp$ret$0;
+  }
+}
+class GeneratedSerializer {}
+function typeParametersSerializers() {
+  return get_EMPTY_SERIALIZER_ARRAY();
+}
+class InlinePrimitiveDescriptor$1 {
+  constructor($primitiveSerializer) {
+    this.ev_1 = $primitiveSerializer;
+  }
+  fv() {
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    return [this.ev_1];
+  }
+  io() {
+    var message = 'unsupported';
+    throw IllegalStateException.e4(toString(message));
+  }
+  jo(encoder, value) {
+    // Inline function 'kotlin.error' call
+    var message = 'unsupported';
+    throw IllegalStateException.e4(toString(message));
+  }
+}
+class NoOpEncoder extends AbstractEncoder {
+  static iv() {
+    NoOpEncoder_instance = null;
+    var $this = this.qq();
+    NoOpEncoder_instance = $this;
+    $this.hv_1 = EmptySerializersModule_0();
+    return $this;
+  }
+  ur() {
+    return this.hv_1;
+  }
+  uq(value) {
+    return Unit_instance;
+  }
+  vq() {
+    return Unit_instance;
+  }
+  wq(value) {
+    return Unit_instance;
+  }
+  xq(value) {
+    return Unit_instance;
+  }
+  yq(value) {
+    return Unit_instance;
+  }
+  zq(value) {
+    return Unit_instance;
+  }
+  ar(value) {
+    return Unit_instance;
+  }
+  br(value) {
+    return Unit_instance;
+  }
+  cr(value) {
+    return Unit_instance;
+  }
+  dr(value) {
+    return Unit_instance;
+  }
+  er(value) {
+    return Unit_instance;
+  }
+}
+class NothingSerialDescriptor {
+  constructor() {
+    NothingSerialDescriptor_instance = this;
+    this.jv_1 = OBJECT_getInstance();
+    this.kv_1 = 'kotlin.Nothing';
+  }
+  qp() {
+    return this.jv_1;
+  }
+  pp() {
+    return this.kv_1;
+  }
+  sp() {
+    return 0;
+  }
+  up(index) {
+    error(this);
+  }
+  vp(index) {
+    error(this);
+  }
+  toString() {
+    return 'NothingSerialDescriptor';
+  }
+  equals(other) {
+    return this === other;
+  }
+  hashCode() {
+    return getStringHashCode(this.kv_1) + imul(31, this.jv_1.hashCode()) | 0;
+  }
+}
+class NullableSerializer {
+  constructor(serializer) {
+    this.lv_1 = serializer;
+    this.mv_1 = new SerialDescriptorForNullable(this.lv_1.io());
+  }
+  io() {
+    return this.mv_1;
+  }
+  nv(encoder, value) {
+    if (!(value == null)) {
+      encoder.vr();
+      encoder.rr(this.lv_1, value);
+    } else {
+      encoder.vq();
+    }
+  }
+  jo(encoder, value) {
+    return this.nv(encoder, (value == null ? true : !(value == null)) ? value : THROW_CCE());
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (other == null || !getKClassFromExpression(this).equals(getKClassFromExpression(other)))
+      return false;
+    if (!(other instanceof NullableSerializer))
+      THROW_CCE();
+    if (!equals(this.lv_1, other.lv_1))
+      return false;
+    return true;
+  }
+  hashCode() {
+    return hashCode(this.lv_1);
+  }
+}
+class SerialDescriptorForNullable {
+  constructor(original) {
+    this.wp_1 = original;
+    this.xp_1 = this.wp_1.pp() + '?';
+    this.yp_1 = cachedSerialNames(this.wp_1);
+  }
+  pp() {
+    return this.xp_1;
+  }
+  pq() {
+    return this.yp_1;
+  }
+  lp() {
+    return true;
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof SerialDescriptorForNullable))
+      return false;
+    if (!equals(this.wp_1, other.wp_1))
+      return false;
+    return true;
+  }
+  toString() {
+    return toString(this.wp_1) + '?';
+  }
+  hashCode() {
+    return imul(hashCode(this.wp_1), 31);
+  }
+  qp() {
+    return this.wp_1.qp();
+  }
+  rp() {
+    return this.wp_1.rp();
+  }
+  sp() {
+    return this.wp_1.sp();
+  }
+  tp() {
+    return this.wp_1.tp();
+  }
+  up(index) {
+    return this.wp_1.up(index);
+  }
+  vp(index) {
+    return this.wp_1.vp(index);
+  }
+}
+class ObjectSerializer {
+  constructor(serialName, objectInstance) {
+    this.ov_1 = objectInstance;
+    this.pv_1 = emptyList();
+    var tmp = this;
+    var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+    tmp.qv_1 = lazy(tmp_0, ObjectSerializer$descriptor$delegate$lambda(serialName, this));
+  }
+  io() {
+    var tmp0 = this.qv_1;
+    // Inline function 'kotlin.getValue' call
+    descriptor$factory_1();
+    return tmp0.s1();
+  }
+  xo(encoder, value) {
+    encoder.rq(this.io()).sq(this.io());
+  }
+  jo(encoder, value) {
+    return this.xo(encoder, !(value == null) ? value : THROW_CCE());
+  }
+}
+class SerializerFactory {}
+class CharArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    CharArraySerializer_instance = null;
+    super(serializer_1(Companion_getInstance()));
+    CharArraySerializer_instance = this;
+  }
+  uv(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.uv((!(_this__u8e3s4 == null) ? isCharArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  vv(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.nr(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.vv(encoder, (!(content == null) ? isCharArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class DoubleArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    DoubleArraySerializer_instance = null;
+    super(serializer_2(DoubleCompanionObject_instance));
+    DoubleArraySerializer_instance = this;
+  }
+  yv(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.yv((!(_this__u8e3s4 == null) ? isDoubleArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  zv(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.mr(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.zv(encoder, (!(content == null) ? isDoubleArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class FloatArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    FloatArraySerializer_instance = null;
+    super(serializer_3(FloatCompanionObject_instance));
+    FloatArraySerializer_instance = this;
+  }
+  cw(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.cw((!(_this__u8e3s4 == null) ? isFloatArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  dw(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.lr(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.dw(encoder, (!(content == null) ? isFloatArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class LongArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    LongArraySerializer_instance = null;
+    super(serializer_4(Companion_getInstance_0()));
+    LongArraySerializer_instance = this;
+  }
+  gw(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.gw((!(_this__u8e3s4 == null) ? isLongArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  hw(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.kr(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.hw(encoder, (!(content == null) ? isLongArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class ULongArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    ULongArraySerializer_instance = null;
+    super(serializer_5(Companion_getInstance_1()));
+    ULongArraySerializer_instance = this;
+  }
+  kw(_this__u8e3s4) {
+    return _ULongArray___get_size__impl__ju6dtr(_this__u8e3s4);
+  }
+  lt(_this__u8e3s4) {
+    return this.kw(_this__u8e3s4 instanceof ULongArray ? _this__u8e3s4.vn_1 : THROW_CCE());
+  }
+  lw(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp = encoder.pr(this.zt_1, i);
+        // Inline function 'kotlin.ULong.toLong' call
+        var this_0 = ULongArray__get_impl_pr71q9(content, i);
+        var tmp$ret$0 = _ULong___get_data__impl__fggpzb(this_0);
+        tmp.ar(tmp$ret$0);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.lw(encoder, content instanceof ULongArray ? content.vn_1 : THROW_CCE(), size);
+  }
+}
+class IntArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    IntArraySerializer_instance = null;
+    super(serializer_6(IntCompanionObject_instance));
+    IntArraySerializer_instance = this;
+  }
+  ow(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.ow((!(_this__u8e3s4 == null) ? isIntArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  pw(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.jr(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.pw(encoder, (!(content == null) ? isIntArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class UIntArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    UIntArraySerializer_instance = null;
+    super(serializer_7(Companion_getInstance_2()));
+    UIntArraySerializer_instance = this;
+  }
+  sw(_this__u8e3s4) {
+    return _UIntArray___get_size__impl__r6l8ci(_this__u8e3s4);
+  }
+  lt(_this__u8e3s4) {
+    return this.sw(_this__u8e3s4 instanceof UIntArray ? _this__u8e3s4.kn_1 : THROW_CCE());
+  }
+  tw(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp = encoder.pr(this.zt_1, i);
+        // Inline function 'kotlin.UInt.toInt' call
+        var this_0 = UIntArray__get_impl_gp5kza(content, i);
+        var tmp$ret$0 = _UInt___get_data__impl__f0vqqw(this_0);
+        tmp.zq(tmp$ret$0);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.tw(encoder, content instanceof UIntArray ? content.kn_1 : THROW_CCE(), size);
+  }
+}
+class ShortArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    ShortArraySerializer_instance = null;
+    super(serializer_8(ShortCompanionObject_instance));
+    ShortArraySerializer_instance = this;
+  }
+  ww(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.ww((!(_this__u8e3s4 == null) ? isShortArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  xw(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.ir(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.xw(encoder, (!(content == null) ? isShortArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class UShortArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    UShortArraySerializer_instance = null;
+    super(serializer_9(Companion_getInstance_3()));
+    UShortArraySerializer_instance = this;
+  }
+  ax(_this__u8e3s4) {
+    return _UShortArray___get_size__impl__jqto1b(_this__u8e3s4);
+  }
+  lt(_this__u8e3s4) {
+    return this.ax(_this__u8e3s4 instanceof UShortArray ? _this__u8e3s4.go_1 : THROW_CCE());
+  }
+  bx(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp = encoder.pr(this.zt_1, i);
+        // Inline function 'kotlin.UShort.toShort' call
+        var this_0 = UShortArray__get_impl_fnbhmx(content, i);
+        var tmp$ret$0 = _UShort___get_data__impl__g0245(this_0);
+        tmp.yq(tmp$ret$0);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.bx(encoder, content instanceof UShortArray ? content.go_1 : THROW_CCE(), size);
+  }
+}
+class ByteArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    ByteArraySerializer_instance = null;
+    super(serializer_10(ByteCompanionObject_instance));
+    ByteArraySerializer_instance = this;
+  }
+  ex(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.ex((!(_this__u8e3s4 == null) ? isByteArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  fx(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.hr(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.fx(encoder, (!(content == null) ? isByteArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class UByteArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    UByteArraySerializer_instance = null;
+    super(serializer_11(Companion_getInstance_4()));
+    UByteArraySerializer_instance = this;
+  }
+  ix(_this__u8e3s4) {
+    return _UByteArray___get_size__impl__h6pkdv(_this__u8e3s4);
+  }
+  lt(_this__u8e3s4) {
+    return this.ix(_this__u8e3s4 instanceof UByteArray ? _this__u8e3s4.zm_1 : THROW_CCE());
+  }
+  jx(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp = encoder.pr(this.zt_1, i);
+        // Inline function 'kotlin.UByte.toByte' call
+        var this_0 = UByteArray__get_impl_t5f3hv(content, i);
+        var tmp$ret$0 = _UByte___get_data__impl__jof9qr(this_0);
+        tmp.xq(tmp$ret$0);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.jx(encoder, content instanceof UByteArray ? content.zm_1 : THROW_CCE(), size);
+  }
+}
+class BooleanArraySerializer extends PrimitiveArraySerializer {
+  constructor() {
+    BooleanArraySerializer_instance = null;
+    super(serializer_12(BooleanCompanionObject_instance));
+    BooleanArraySerializer_instance = this;
+  }
+  mx(_this__u8e3s4) {
+    return _this__u8e3s4.length;
+  }
+  lt(_this__u8e3s4) {
+    return this.mx((!(_this__u8e3s4 == null) ? isBooleanArray(_this__u8e3s4) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  nx(encoder, content, size) {
+    var inductionVariable = 0;
+    if (inductionVariable < size)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        encoder.gr(this.zt_1, i, content[i]);
+      }
+       while (inductionVariable < size);
+  }
+  bu(encoder, content, size) {
+    return this.nx(encoder, (!(content == null) ? isBooleanArray(content) : false) ? content : THROW_CCE(), size);
+  }
+}
+class StringSerializer {
+  constructor() {
+    StringSerializer_instance = this;
+    this.ox_1 = new PrimitiveSerialDescriptor('kotlin.String', STRING_getInstance());
+  }
+  io() {
+    return this.ox_1;
+  }
+  px(encoder, value) {
+    return encoder.er(value);
+  }
+  jo(encoder, value) {
+    return this.px(encoder, (!(value == null) ? typeof value === 'string' : false) ? value : THROW_CCE());
+  }
+}
+class CharSerializer {
+  constructor() {
+    CharSerializer_instance = this;
+    this.qx_1 = new PrimitiveSerialDescriptor('kotlin.Char', CHAR_getInstance());
+  }
+  io() {
+    return this.qx_1;
+  }
+  rx(encoder, value) {
+    return encoder.dr(value);
+  }
+  jo(encoder, value) {
+    return this.rx(encoder, value instanceof Char ? value.y1_1 : THROW_CCE());
+  }
+}
+class DoubleSerializer {
+  constructor() {
+    DoubleSerializer_instance = this;
+    this.sx_1 = new PrimitiveSerialDescriptor('kotlin.Double', DOUBLE_getInstance());
+  }
+  io() {
+    return this.sx_1;
+  }
+  tx(encoder, value) {
+    return encoder.cr(value);
+  }
+  jo(encoder, value) {
+    return this.tx(encoder, (!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+  }
+}
+class FloatSerializer {
+  constructor() {
+    FloatSerializer_instance = this;
+    this.ux_1 = new PrimitiveSerialDescriptor('kotlin.Float', FLOAT_getInstance());
+  }
+  io() {
+    return this.ux_1;
+  }
+  vx(encoder, value) {
+    return encoder.br(value);
+  }
+  jo(encoder, value) {
+    return this.vx(encoder, (!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+  }
+}
+class LongSerializer {
+  constructor() {
+    LongSerializer_instance = this;
+    this.wx_1 = new PrimitiveSerialDescriptor('kotlin.Long', LONG_getInstance());
+  }
+  io() {
+    return this.wx_1;
+  }
+  xx(encoder, value) {
+    return encoder.ar(value);
+  }
+  jo(encoder, value) {
+    return this.xx(encoder, value instanceof Long ? value : THROW_CCE());
+  }
+}
+class IntSerializer {
+  constructor() {
+    IntSerializer_instance = this;
+    this.yx_1 = new PrimitiveSerialDescriptor('kotlin.Int', INT_getInstance());
+  }
+  io() {
+    return this.yx_1;
+  }
+  zx(encoder, value) {
+    return encoder.zq(value);
+  }
+  jo(encoder, value) {
+    return this.zx(encoder, (!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+  }
+}
+class ShortSerializer {
+  constructor() {
+    ShortSerializer_instance = this;
+    this.ay_1 = new PrimitiveSerialDescriptor('kotlin.Short', SHORT_getInstance());
+  }
+  io() {
+    return this.ay_1;
+  }
+  by(encoder, value) {
+    return encoder.yq(value);
+  }
+  jo(encoder, value) {
+    return this.by(encoder, (!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+  }
+}
+class ByteSerializer {
+  constructor() {
+    ByteSerializer_instance = this;
+    this.cy_1 = new PrimitiveSerialDescriptor('kotlin.Byte', BYTE_getInstance());
+  }
+  io() {
+    return this.cy_1;
+  }
+  dy(encoder, value) {
+    return encoder.xq(value);
+  }
+  jo(encoder, value) {
+    return this.dy(encoder, (!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+  }
+}
+class BooleanSerializer {
+  constructor() {
+    BooleanSerializer_instance = this;
+    this.ey_1 = new PrimitiveSerialDescriptor('kotlin.Boolean', BOOLEAN_getInstance());
+  }
+  io() {
+    return this.ey_1;
+  }
+  fy(encoder, value) {
+    return encoder.wq(value);
+  }
+  jo(encoder, value) {
+    return this.fy(encoder, (!(value == null) ? typeof value === 'boolean' : false) ? value : THROW_CCE());
+  }
+}
+class UnitSerializer {
+  constructor() {
+    UnitSerializer_instance = this;
+    this.gy_1 = new ObjectSerializer('kotlin.Unit', Unit_instance);
+  }
+  io() {
+    return this.gy_1.io();
+  }
+  hy(encoder, value) {
+    this.gy_1.xo(encoder, Unit_instance);
+  }
+  jo(encoder, value) {
+    return this.hy(encoder, value instanceof Unit ? value : THROW_CCE());
+  }
+}
+class PrimitiveSerialDescriptor {
+  constructor(serialName, kind) {
+    this.iy_1 = serialName;
+    this.jy_1 = kind;
+  }
+  pp() {
+    return this.iy_1;
+  }
+  qp() {
+    return this.jy_1;
+  }
+  sp() {
+    return 0;
+  }
+  up(index) {
+    error_0(this);
+  }
+  vp(index) {
+    error_0(this);
+  }
+  toString() {
+    return 'PrimitiveDescriptor(' + this.iy_1 + ')';
+  }
+  equals(other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof PrimitiveSerialDescriptor))
+      return false;
+    if (this.iy_1 === other.iy_1 && equals(this.jy_1, other.jy_1))
+      return true;
+    return false;
+  }
+  hashCode() {
+    return getStringHashCode(this.iy_1) + imul(31, this.jy_1.hashCode()) | 0;
+  }
+}
+class KeyValueSerializer {
+  constructor(keySerializer, valueSerializer) {
+    this.ry_1 = keySerializer;
+    this.sy_1 = valueSerializer;
+  }
+  ty(encoder, value) {
+    var structuredEncoder = encoder.rq(this.io());
+    structuredEncoder.qr(this.io(), 0, this.ry_1, this.oy(value));
+    structuredEncoder.qr(this.io(), 1, this.sy_1, this.qy(value));
+    structuredEncoder.sq(this.io());
+  }
+  jo(encoder, value) {
+    return this.ty(encoder, (value == null ? true : !(value == null)) ? value : THROW_CCE());
+  }
+}
+class MapEntrySerializer extends KeyValueSerializer {
+  constructor(keySerializer, valueSerializer) {
+    super(keySerializer, valueSerializer);
+    var tmp = this;
+    var tmp_0 = MAP_getInstance();
+    tmp.my_1 = buildSerialDescriptor('kotlin.collections.Map.Entry', tmp_0, [], MapEntrySerializer$descriptor$lambda(keySerializer, valueSerializer));
+  }
+  io() {
+    return this.my_1;
+  }
+  ny(_this__u8e3s4) {
+    return _this__u8e3s4.r1();
+  }
+  oy(_this__u8e3s4) {
+    return this.ny((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, Entry) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+  py(_this__u8e3s4) {
+    return _this__u8e3s4.s1();
+  }
+  qy(_this__u8e3s4) {
+    return this.py((!(_this__u8e3s4 == null) ? isInterface(_this__u8e3s4, Entry) : false) ? _this__u8e3s4 : THROW_CCE());
+  }
+}
+class PairSerializer extends KeyValueSerializer {
+  constructor(keySerializer, valueSerializer) {
+    super(keySerializer, valueSerializer);
+    var tmp = this;
+    tmp.wy_1 = buildClassSerialDescriptor('kotlin.Pair', [], PairSerializer$descriptor$lambda(keySerializer, valueSerializer));
+  }
+  io() {
+    return this.wy_1;
+  }
+  xy(_this__u8e3s4) {
+    return _this__u8e3s4.wd_1;
+  }
+  oy(_this__u8e3s4) {
+    return this.xy(_this__u8e3s4 instanceof Pair ? _this__u8e3s4 : THROW_CCE());
+  }
+  yy(_this__u8e3s4) {
+    return _this__u8e3s4.xd_1;
+  }
+  qy(_this__u8e3s4) {
+    return this.yy(_this__u8e3s4 instanceof Pair ? _this__u8e3s4 : THROW_CCE());
+  }
+}
+class TripleSerializer {
+  constructor(aSerializer, bSerializer, cSerializer) {
+    this.zy_1 = aSerializer;
+    this.az_1 = bSerializer;
+    this.bz_1 = cSerializer;
+    var tmp = this;
+    tmp.cz_1 = buildClassSerialDescriptor('kotlin.Triple', [], TripleSerializer$descriptor$lambda(this));
+  }
+  io() {
+    return this.cz_1;
+  }
+  dz(encoder, value) {
+    var structuredEncoder = encoder.rq(this.cz_1);
+    structuredEncoder.qr(this.cz_1, 0, this.zy_1, value.fm_1);
+    structuredEncoder.qr(this.cz_1, 1, this.az_1, value.gm_1);
+    structuredEncoder.qr(this.cz_1, 2, this.bz_1, value.hm_1);
+    structuredEncoder.sq(this.cz_1);
+  }
+  jo(encoder, value) {
+    return this.dz(encoder, value instanceof Triple ? value : THROW_CCE());
+  }
+}
+class ULongSerializer {
+  constructor() {
+    ULongSerializer_instance = this;
+    this.ez_1 = InlinePrimitiveDescriptor('kotlin.ULong', serializer_4(Companion_getInstance_0()));
+  }
+  io() {
+    return this.ez_1;
+  }
+  fz(encoder, value) {
+    var tmp = encoder.fr(this.ez_1);
+    // Inline function 'kotlin.ULong.toLong' call
+    var tmp$ret$0 = _ULong___get_data__impl__fggpzb(value);
+    tmp.ar(tmp$ret$0);
+  }
+  jo(encoder, value) {
+    return this.fz(encoder, value instanceof ULong ? value.qn_1 : THROW_CCE());
+  }
+}
+class UIntSerializer {
+  constructor() {
+    UIntSerializer_instance = this;
+    this.gz_1 = InlinePrimitiveDescriptor('kotlin.UInt', serializer_6(IntCompanionObject_instance));
+  }
+  io() {
+    return this.gz_1;
+  }
+  hz(encoder, value) {
+    var tmp = encoder.fr(this.gz_1);
+    // Inline function 'kotlin.UInt.toInt' call
+    var tmp$ret$0 = _UInt___get_data__impl__f0vqqw(value);
+    tmp.zq(tmp$ret$0);
+  }
+  jo(encoder, value) {
+    return this.hz(encoder, value instanceof UInt ? value.fn_1 : THROW_CCE());
+  }
+}
+class UShortSerializer {
+  constructor() {
+    UShortSerializer_instance = this;
+    this.iz_1 = InlinePrimitiveDescriptor('kotlin.UShort', serializer_8(ShortCompanionObject_instance));
+  }
+  io() {
+    return this.iz_1;
+  }
+  jz(encoder, value) {
+    var tmp = encoder.fr(this.iz_1);
+    // Inline function 'kotlin.UShort.toShort' call
+    var tmp$ret$0 = _UShort___get_data__impl__g0245(value);
+    tmp.yq(tmp$ret$0);
+  }
+  jo(encoder, value) {
+    return this.jz(encoder, value instanceof UShort ? value.bo_1 : THROW_CCE());
+  }
+}
+class UByteSerializer {
+  constructor() {
+    UByteSerializer_instance = this;
+    this.kz_1 = InlinePrimitiveDescriptor('kotlin.UByte', serializer_10(ByteCompanionObject_instance));
+  }
+  io() {
+    return this.kz_1;
+  }
+  lz(encoder, value) {
+    var tmp = encoder.fr(this.kz_1);
+    // Inline function 'kotlin.UByte.toByte' call
+    var tmp$ret$0 = _UByte___get_data__impl__jof9qr(value);
+    tmp.xq(tmp$ret$0);
+  }
+  jo(encoder, value) {
+    return this.lz(encoder, value instanceof UByte ? value.um_1 : THROW_CCE());
+  }
+}
+class SerializersModule {
+  hp(kClass, typeArgumentsSerializers, $super) {
+    typeArgumentsSerializers = typeArgumentsSerializers === VOID ? emptyList() : typeArgumentsSerializers;
+    return $super === VOID ? this.ip(kClass, typeArgumentsSerializers) : $super.ip.call(this, kClass, typeArgumentsSerializers);
+  }
+}
+class SerialModuleImpl extends SerializersModule {
+  constructor(class2ContextualFactory, polyBase2Serializers, polyBase2DefaultSerializerProvider, polyBase2NamedSerializers, polyBase2DefaultDeserializerProvider, hasInterfaceContextualSerializers) {
+    super();
+    this.mz_1 = class2ContextualFactory;
+    this.nz_1 = polyBase2Serializers;
+    this.oz_1 = polyBase2DefaultSerializerProvider;
+    this.pz_1 = polyBase2NamedSerializers;
+    this.qz_1 = polyBase2DefaultDeserializerProvider;
+    this.rz_1 = hasInterfaceContextualSerializers;
+  }
+  gp() {
+    return this.rz_1;
+  }
+  yr(baseClass, value) {
+    if (!baseClass.de(value))
+      return null;
+    var tmp0_safe_receiver = this.nz_1.p2(baseClass);
+    var tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.p2(getKClassFromExpression(value));
+    var registered = (!(tmp == null) ? isInterface(tmp, SerializationStrategy) : false) ? tmp : null;
+    if (!(registered == null))
+      return registered;
+    var tmp_0 = this.oz_1.p2(baseClass);
+    var tmp1_safe_receiver = (!(tmp_0 == null) ? typeof tmp_0 === 'function' : false) ? tmp_0 : null;
+    return tmp1_safe_receiver == null ? null : tmp1_safe_receiver(value);
+  }
+  ip(kClass, typeArgumentsSerializers) {
+    var tmp0_safe_receiver = this.mz_1.p2(kClass);
+    var tmp = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.sz(typeArgumentsSerializers);
+    return (tmp == null ? true : isInterface(tmp, KSerializer)) ? tmp : null;
+  }
+}
+class SerializableWith {
+  constructor(serializer) {
+    this.tz_1 = serializer;
+  }
+  equals(other) {
+    if (!(other instanceof SerializableWith))
+      return false;
+    var tmp0_other_with_cast = other instanceof SerializableWith ? other : THROW_CCE();
+    if (!this.tz_1.equals(tmp0_other_with_cast.tz_1))
+      return false;
+    return true;
+  }
+  hashCode() {
+    return imul(getStringHashCode('serializer'), 127) ^ this.tz_1.hashCode();
+  }
+  toString() {
+    return '@kotlinx.serialization.SerializableWith(' + 'serializer=' + toString(this.tz_1) + ')';
+  }
+}
+class createCache$1 {
+  constructor($factory) {
+    this.uz_1 = $factory;
+  }
+  jp(key) {
+    return this.uz_1(key);
+  }
+}
+class createParametrizedCache$1 {
+  constructor($factory) {
+    this.vz_1 = $factory;
+  }
+  kp(key, types) {
+    // Inline function 'kotlin.runCatching' call
+    var tmp;
+    try {
+      // Inline function 'kotlinx.serialization.internal.<no name provided>.get.<anonymous>' call
+      // Inline function 'kotlin.Companion.success' call
+      var value = this.vz_1(key, types);
+      tmp = _Result___init__impl__xyqfz8(value);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Error) {
+        var e = $p;
+        // Inline function 'kotlin.Companion.failure' call
+        tmp_0 = _Result___init__impl__xyqfz8(createFailure(e));
+      } else {
+        throw $p;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+}
+//endregion
+function PolymorphicSerializer$descriptor$delegate$lambda$lambda(this$0) {
+  return ($this$buildSerialDescriptor) => {
+    $this$buildSerialDescriptor.so('type', serializer_0(StringCompanionObject_instance).io());
+    $this$buildSerialDescriptor.so('value', buildSerialDescriptor('kotlinx.serialization.Polymorphic<' + this$0.to_1.ce() + '>', CONTEXTUAL_getInstance(), []));
+    $this$buildSerialDescriptor.mo_1 = this$0.uo_1;
+    return Unit_instance;
+  };
+}
+function PolymorphicSerializer$descriptor$delegate$lambda(this$0) {
+  return () => {
+    var tmp = OPEN_getInstance();
+    return withContext(buildSerialDescriptor('kotlinx.serialization.Polymorphic', tmp, [], PolymorphicSerializer$descriptor$delegate$lambda$lambda(this$0)), this$0.to_1);
+  };
+}
+function findPolymorphicSerializer(_this__u8e3s4, encoder, value) {
+  var tmp0_elvis_lhs = _this__u8e3s4.yo(encoder, value);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throwSubtypeNotRegistered(getKClassFromExpression(value), _this__u8e3s4.wo());
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function descriptor$factory() {
+  return getPropertyCallableRef('descriptor', 1, KProperty1, (receiver) => receiver.io(), null);
+}
+function descriptor$factory_0() {
+  return getPropertyCallableRef('descriptor', 1, KProperty1, (receiver) => receiver.io(), null);
+}
+function init_kotlinx_serialization_SerializationException(_this__u8e3s4) {
+  captureStack(_this__u8e3s4, _this__u8e3s4.dp_1);
+}
+function serializerOrNull(_this__u8e3s4) {
+  var tmp0_elvis_lhs = compiledSerializerImpl(_this__u8e3s4);
+  return tmp0_elvis_lhs == null ? builtinSerializerOrNull(_this__u8e3s4) : tmp0_elvis_lhs;
+}
+function serializersForParameters(_this__u8e3s4, typeArguments, failOnMissingTypeArgSerializer) {
+  var tmp;
+  if (failOnMissingTypeArgSerializer) {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList.k1(collectionSizeOrDefault(typeArguments, 10));
+    var _iterator__ex2g4s = typeArguments.d1();
+    while (_iterator__ex2g4s.e1()) {
+      var item = _iterator__ex2g4s.f1();
+      // Inline function 'kotlinx.serialization.serializersForParameters.<anonymous>' call
+      var tmp$ret$0 = serializer(_this__u8e3s4, item);
+      destination.o(tmp$ret$0);
+    }
+    tmp = destination;
+  } else {
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList.k1(collectionSizeOrDefault(typeArguments, 10));
+    var _iterator__ex2g4s_0 = typeArguments.d1();
+    while (_iterator__ex2g4s_0.e1()) {
+      var item_0 = _iterator__ex2g4s_0.f1();
+      // Inline function 'kotlinx.serialization.serializersForParameters.<anonymous>' call
+      var tmp0_elvis_lhs = serializerOrNull_0(_this__u8e3s4, item_0);
+      var tmp_0;
+      if (tmp0_elvis_lhs == null) {
+        return null;
+      } else {
+        tmp_0 = tmp0_elvis_lhs;
+      }
+      var tmp$ret$3 = tmp_0;
+      destination_0.o(tmp$ret$3);
+    }
+    tmp = destination_0;
+  }
+  var serializers = tmp;
+  return serializers;
+}
+function parametrizedSerializerOrNull(_this__u8e3s4, serializers, elementClassifierIfArray) {
+  var tmp0_elvis_lhs = builtinParametrizedSerializer(_this__u8e3s4, serializers, elementClassifierIfArray);
+  return tmp0_elvis_lhs == null ? compiledParametrizedSerializer(_this__u8e3s4, serializers) : tmp0_elvis_lhs;
+}
+function serializer(_this__u8e3s4, type) {
+  var tmp0_elvis_lhs = serializerByKTypeImpl(_this__u8e3s4, type, true);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    platformSpecificSerializerNotRegistered(kclass(type));
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function serializerOrNull_0(_this__u8e3s4, type) {
+  return serializerByKTypeImpl(_this__u8e3s4, type, false);
+}
+function builtinParametrizedSerializer(_this__u8e3s4, serializers, elementClassifierIfArray) {
+  var tmp;
+  if (_this__u8e3s4.equals(getKClass(Collection)) || _this__u8e3s4.equals(getKClass(KtList)) || (_this__u8e3s4.equals(getKClass(KtMutableList)) || _this__u8e3s4.equals(getKClass(ArrayList)))) {
+    tmp = new ArrayListSerializer(serializers.j1(0));
+  } else if (_this__u8e3s4.equals(getKClass(HashSet))) {
+    tmp = new HashSetSerializer(serializers.j1(0));
+  } else if (_this__u8e3s4.equals(getKClass(KtSet)) || (_this__u8e3s4.equals(getKClass(KtMutableSet)) || _this__u8e3s4.equals(getKClass(LinkedHashSet)))) {
+    tmp = new LinkedHashSetSerializer(serializers.j1(0));
+  } else if (_this__u8e3s4.equals(getKClass(HashMap))) {
+    tmp = new HashMapSerializer(serializers.j1(0), serializers.j1(1));
+  } else if (_this__u8e3s4.equals(getKClass(KtMap)) || (_this__u8e3s4.equals(getKClass(KtMutableMap)) || _this__u8e3s4.equals(getKClass(LinkedHashMap)))) {
+    tmp = new LinkedHashMapSerializer(serializers.j1(0), serializers.j1(1));
+  } else if (_this__u8e3s4.equals(getKClass(Entry))) {
+    tmp = MapEntrySerializer_0(serializers.j1(0), serializers.j1(1));
+  } else if (_this__u8e3s4.equals(getKClass(Pair))) {
+    tmp = PairSerializer_0(serializers.j1(0), serializers.j1(1));
+  } else if (_this__u8e3s4.equals(getKClass(Triple))) {
+    tmp = TripleSerializer_0(serializers.j1(0), serializers.j1(1), serializers.j1(2));
+  } else {
+    var tmp_0;
+    if (isReferenceArray(_this__u8e3s4)) {
+      var tmp_1 = elementClassifierIfArray();
+      tmp_0 = ArraySerializer((!(tmp_1 == null) ? isInterface(tmp_1, KClass) : false) ? tmp_1 : THROW_CCE(), serializers.j1(0));
+    } else {
+      tmp_0 = null;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+}
+function compiledParametrizedSerializer(_this__u8e3s4, serializers) {
+  // Inline function 'kotlin.collections.toTypedArray' call
+  var tmp$ret$0 = copyToArray(serializers);
+  return constructSerializerForGivenTypeArgs(_this__u8e3s4, tmp$ret$0.slice());
+}
+function serializerByKTypeImpl(_this__u8e3s4, type, failOnMissingTypeArgSerializer) {
+  var rootClass = kclass(type);
+  var isNullable = type.se();
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = type.re();
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList.k1(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.d1();
+  while (_iterator__ex2g4s.e1()) {
+    var item = _iterator__ex2g4s.f1();
+    // Inline function 'kotlinx.serialization.serializerByKTypeImpl.stub_for_inlining' call
+    var tmp$ret$0 = typeOrThrow(item);
+    destination.o(tmp$ret$0);
+  }
+  var typeArguments = destination;
+  var tmp;
+  if (typeArguments.a1()) {
+    var tmp_0;
+    if (isInterface_0(rootClass) && !(_this__u8e3s4.hp(rootClass) == null)) {
+      tmp_0 = null;
+    } else {
+      tmp_0 = findCachedSerializer(rootClass, isNullable);
+    }
+    tmp = tmp_0;
+  } else {
+    var tmp_1;
+    if (_this__u8e3s4.gp()) {
+      tmp_1 = null;
+    } else {
+      // Inline function 'kotlin.Result.getOrNull' call
+      var this_1 = findParametrizedCachedSerializer(rootClass, typeArguments, isNullable);
+      var tmp_2;
+      if (_Result___get_isFailure__impl__jpiriv(this_1)) {
+        tmp_2 = null;
+      } else {
+        var tmp_3 = _Result___get_value__impl__bjfvqg(this_1);
+        tmp_2 = (tmp_3 == null ? true : !(tmp_3 == null)) ? tmp_3 : THROW_CCE();
+      }
+      tmp_1 = tmp_2;
+    }
+    tmp = tmp_1;
+  }
+  var cachedSerializer = tmp;
+  if (!(cachedSerializer == null))
+    return cachedSerializer;
+  var tmp_4;
+  if (typeArguments.a1()) {
+    var tmp0_elvis_lhs = serializerOrNull(rootClass);
+    var tmp1_elvis_lhs = tmp0_elvis_lhs == null ? _this__u8e3s4.hp(rootClass) : tmp0_elvis_lhs;
+    var tmp_5;
+    if (tmp1_elvis_lhs == null) {
+      // Inline function 'kotlinx.serialization.polymorphicIfInterface' call
+      tmp_5 = isInterface_0(rootClass) ? new PolymorphicSerializer(rootClass) : null;
+    } else {
+      tmp_5 = tmp1_elvis_lhs;
+    }
+    tmp_4 = tmp_5;
+  } else {
+    var tmp2_elvis_lhs = serializersForParameters(_this__u8e3s4, typeArguments, failOnMissingTypeArgSerializer);
+    var tmp_6;
+    if (tmp2_elvis_lhs == null) {
+      return null;
+    } else {
+      tmp_6 = tmp2_elvis_lhs;
+    }
+    var serializers = tmp_6;
+    var tmp3_elvis_lhs = parametrizedSerializerOrNull(rootClass, serializers, serializerByKTypeImpl$lambda(typeArguments));
+    var tmp4_elvis_lhs = tmp3_elvis_lhs == null ? _this__u8e3s4.ip(rootClass, serializers) : tmp3_elvis_lhs;
+    var tmp_7;
+    if (tmp4_elvis_lhs == null) {
+      // Inline function 'kotlinx.serialization.polymorphicIfInterface' call
+      tmp_7 = isInterface_0(rootClass) ? new PolymorphicSerializer(rootClass) : null;
+    } else {
+      tmp_7 = tmp4_elvis_lhs;
+    }
+    tmp_4 = tmp_7;
+  }
+  var contextualSerializer = tmp_4;
+  var tmp_8;
+  if (contextualSerializer == null) {
+    tmp_8 = null;
+  } else {
+    // Inline function 'kotlinx.serialization.internal.cast' call
+    tmp_8 = isInterface(contextualSerializer, KSerializer) ? contextualSerializer : THROW_CCE();
+  }
+  var tmp6_safe_receiver = tmp_8;
+  return tmp6_safe_receiver == null ? null : nullable(tmp6_safe_receiver, isNullable);
+}
+function nullable(_this__u8e3s4, shouldBeNullable) {
+  if (shouldBeNullable)
+    return get_nullable(_this__u8e3s4);
+  return isInterface(_this__u8e3s4, KSerializer) ? _this__u8e3s4 : THROW_CCE();
+}
+function serializerByKTypeImpl$lambda($typeArguments) {
+  return () => $typeArguments.j1(0).qe();
+}
+function get_SERIALIZERS_CACHE() {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  return SERIALIZERS_CACHE;
+}
+var SERIALIZERS_CACHE;
+function get_SERIALIZERS_CACHE_NULLABLE() {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  return SERIALIZERS_CACHE_NULLABLE;
+}
+var SERIALIZERS_CACHE_NULLABLE;
+function get_PARAMETRIZED_SERIALIZERS_CACHE() {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  return PARAMETRIZED_SERIALIZERS_CACHE;
+}
+var PARAMETRIZED_SERIALIZERS_CACHE;
+function get_PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE() {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  return PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE;
+}
+var PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE;
+function findCachedSerializer(clazz, isNullable) {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  var tmp;
+  if (!isNullable) {
+    var tmp0_safe_receiver = get_SERIALIZERS_CACHE().jp(clazz);
+    var tmp_0;
+    if (tmp0_safe_receiver == null) {
+      tmp_0 = null;
+    } else {
+      // Inline function 'kotlinx.serialization.internal.cast' call
+      tmp_0 = isInterface(tmp0_safe_receiver, KSerializer) ? tmp0_safe_receiver : THROW_CCE();
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = get_SERIALIZERS_CACHE_NULLABLE().jp(clazz);
+  }
+  return tmp;
+}
+function findParametrizedCachedSerializer(clazz, types, isNullable) {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  var tmp;
+  if (!isNullable) {
+    var tmp_0 = get_PARAMETRIZED_SERIALIZERS_CACHE().kp(clazz, types);
+    tmp = new Result(tmp_0) instanceof Result ? tmp_0 : THROW_CCE();
+  } else {
+    tmp = get_PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE().kp(clazz, types);
+  }
+  return tmp;
+}
+function SERIALIZERS_CACHE$lambda(it) {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  var tmp0_elvis_lhs = serializerOrNull(it);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlinx.serialization.polymorphicIfInterface' call
+    tmp = isInterface_0(it) ? new PolymorphicSerializer(it) : null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function SERIALIZERS_CACHE_NULLABLE$lambda(it) {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  var tmp0_elvis_lhs = serializerOrNull(it);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    // Inline function 'kotlinx.serialization.polymorphicIfInterface' call
+    tmp = isInterface_0(it) ? new PolymorphicSerializer(it) : null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var tmp1_safe_receiver = tmp;
+  var tmp2_safe_receiver = tmp1_safe_receiver == null ? null : get_nullable(tmp1_safe_receiver);
+  var tmp_0;
+  if (tmp2_safe_receiver == null) {
+    tmp_0 = null;
+  } else {
+    // Inline function 'kotlinx.serialization.internal.cast' call
+    tmp_0 = isInterface(tmp2_safe_receiver, KSerializer) ? tmp2_safe_receiver : THROW_CCE();
+  }
+  return tmp_0;
+}
+function PARAMETRIZED_SERIALIZERS_CACHE$lambda(clazz, types) {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  var serializers = ensureNotNull(serializersForParameters(EmptySerializersModule_0(), types, true));
+  return parametrizedSerializerOrNull(clazz, serializers, PARAMETRIZED_SERIALIZERS_CACHE$lambda$lambda(types));
+}
+function PARAMETRIZED_SERIALIZERS_CACHE$lambda$lambda($types) {
+  return () => $types.j1(0).qe();
+}
+function PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE$lambda(clazz, types) {
+  _init_properties_SerializersCache_kt__hgwi2p();
+  var serializers = ensureNotNull(serializersForParameters(EmptySerializersModule_0(), types, true));
+  var tmp0_safe_receiver = parametrizedSerializerOrNull(clazz, serializers, PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE$lambda$lambda(types));
+  var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : get_nullable(tmp0_safe_receiver);
+  var tmp;
+  if (tmp1_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlinx.serialization.internal.cast' call
+    tmp = isInterface(tmp1_safe_receiver, KSerializer) ? tmp1_safe_receiver : THROW_CCE();
+  }
+  return tmp;
+}
+function PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE$lambda$lambda($types) {
+  return () => $types.j1(0).qe();
+}
+var properties_initialized_SerializersCache_kt_q8kf25;
+function _init_properties_SerializersCache_kt__hgwi2p() {
+  if (!properties_initialized_SerializersCache_kt_q8kf25) {
+    properties_initialized_SerializersCache_kt_q8kf25 = true;
+    SERIALIZERS_CACHE = createCache(SERIALIZERS_CACHE$lambda);
+    SERIALIZERS_CACHE_NULLABLE = createCache(SERIALIZERS_CACHE_NULLABLE$lambda);
+    PARAMETRIZED_SERIALIZERS_CACHE = createParametrizedCache(PARAMETRIZED_SERIALIZERS_CACHE$lambda);
+    PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE = createParametrizedCache(PARAMETRIZED_SERIALIZERS_CACHE_NULLABLE$lambda);
+  }
+}
+function get_nullable(_this__u8e3s4) {
+  var tmp;
+  if (_this__u8e3s4.io().lp()) {
+    tmp = isInterface(_this__u8e3s4, KSerializer) ? _this__u8e3s4 : THROW_CCE();
+  } else {
+    tmp = new NullableSerializer(_this__u8e3s4);
+  }
+  return tmp;
+}
+function serializer_0(_this__u8e3s4) {
+  return StringSerializer_getInstance();
+}
+function serializer_1(_this__u8e3s4) {
+  return CharSerializer_getInstance();
+}
+function CharArraySerializer_0() {
+  return CharArraySerializer_getInstance();
+}
+function serializer_2(_this__u8e3s4) {
+  return DoubleSerializer_getInstance();
+}
+function DoubleArraySerializer_0() {
+  return DoubleArraySerializer_getInstance();
+}
+function serializer_3(_this__u8e3s4) {
+  return FloatSerializer_getInstance();
+}
+function FloatArraySerializer_0() {
+  return FloatArraySerializer_getInstance();
+}
+function serializer_4(_this__u8e3s4) {
+  return LongSerializer_getInstance();
+}
+function LongArraySerializer_0() {
+  return LongArraySerializer_getInstance();
+}
+function serializer_5(_this__u8e3s4) {
+  return ULongSerializer_getInstance();
+}
+function ULongArraySerializer_0() {
+  return ULongArraySerializer_getInstance();
+}
+function serializer_6(_this__u8e3s4) {
+  return IntSerializer_getInstance();
+}
+function IntArraySerializer_0() {
+  return IntArraySerializer_getInstance();
+}
+function serializer_7(_this__u8e3s4) {
+  return UIntSerializer_getInstance();
+}
+function UIntArraySerializer_0() {
+  return UIntArraySerializer_getInstance();
+}
+function serializer_8(_this__u8e3s4) {
+  return ShortSerializer_getInstance();
+}
+function ShortArraySerializer_0() {
+  return ShortArraySerializer_getInstance();
+}
+function serializer_9(_this__u8e3s4) {
+  return UShortSerializer_getInstance();
+}
+function UShortArraySerializer_0() {
+  return UShortArraySerializer_getInstance();
+}
+function serializer_10(_this__u8e3s4) {
+  return ByteSerializer_getInstance();
+}
+function ByteArraySerializer_0() {
+  return ByteArraySerializer_getInstance();
+}
+function serializer_11(_this__u8e3s4) {
+  return UByteSerializer_getInstance();
+}
+function UByteArraySerializer_0() {
+  return UByteArraySerializer_getInstance();
+}
+function serializer_12(_this__u8e3s4) {
+  return BooleanSerializer_getInstance();
+}
+function BooleanArraySerializer_0() {
+  return BooleanArraySerializer_getInstance();
+}
+function serializer_13(_this__u8e3s4) {
+  return UnitSerializer_getInstance();
+}
+function NothingSerializer_0() {
+  return NothingSerializer_getInstance();
+}
+function serializer_14(_this__u8e3s4) {
+  return DurationSerializer_getInstance();
+}
+function serializer_15(_this__u8e3s4) {
+  return UuidSerializer_getInstance();
+}
+function MapEntrySerializer_0(keySerializer, valueSerializer) {
+  return new MapEntrySerializer(keySerializer, valueSerializer);
+}
+function PairSerializer_0(keySerializer, valueSerializer) {
+  return new PairSerializer(keySerializer, valueSerializer);
+}
+function TripleSerializer_0(aSerializer, bSerializer, cSerializer) {
+  return new TripleSerializer(aSerializer, bSerializer, cSerializer);
+}
+function ArraySerializer(kClass, elementSerializer) {
+  return new ReferenceArraySerializer(kClass, elementSerializer);
+}
+function withContext(_this__u8e3s4, context) {
+  return new ContextDescriptor(_this__u8e3s4, context);
+}
+function getContextualDescriptor(_this__u8e3s4, descriptor) {
+  var tmp0_safe_receiver = get_capturedKClass(descriptor);
+  var tmp;
+  if (tmp0_safe_receiver == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    // Inline function 'kotlinx.serialization.descriptors.getContextualDescriptor.<anonymous>' call
+    var tmp0_safe_receiver_0 = _this__u8e3s4.hp(tmp0_safe_receiver);
+    tmp = tmp0_safe_receiver_0 == null ? null : tmp0_safe_receiver_0.io();
+  }
+  return tmp;
+}
+function get_capturedKClass(_this__u8e3s4) {
+  var tmp;
+  if (_this__u8e3s4 instanceof ContextDescriptor) {
+    tmp = _this__u8e3s4.np_1;
+  } else {
+    if (_this__u8e3s4 instanceof SerialDescriptorForNullable) {
+      tmp = get_capturedKClass(_this__u8e3s4.wp_1);
+    } else {
+      tmp = null;
+    }
+  }
+  return tmp;
+}
+function get_elementDescriptors(_this__u8e3s4) {
+  // Inline function 'kotlin.collections.Iterable' call
+  return new elementDescriptors$$inlined$Iterable$1(_this__u8e3s4);
+}
+function buildSerialDescriptor(serialName, kind, typeParameters, builder) {
+  var tmp;
+  if (builder === VOID) {
+    tmp = buildSerialDescriptor$lambda;
+  } else {
+    tmp = builder;
+  }
+  builder = tmp;
+  // Inline function 'kotlin.text.isNotBlank' call
+  // Inline function 'kotlin.require' call
+  if (!!isBlank(serialName)) {
+    // Inline function 'kotlinx.serialization.descriptors.buildSerialDescriptor.<anonymous>' call
+    var message = 'Blank serial names are prohibited';
+    throw IllegalArgumentException.s(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!!equals(kind, CLASS_getInstance())) {
+    // Inline function 'kotlinx.serialization.descriptors.buildSerialDescriptor.<anonymous>' call
+    var message_0 = "For StructureKind.CLASS please use 'buildClassSerialDescriptor' instead";
+    throw IllegalArgumentException.s(toString(message_0));
+  }
+  var sdBuilder = new ClassSerialDescriptorBuilder(serialName);
+  builder(sdBuilder);
+  return new SerialDescriptorImpl(serialName, kind, sdBuilder.no_1.i1(), toList(typeParameters), sdBuilder);
+}
+function _get__hashCode__tgwhef($this) {
+  var tmp0 = $this.oq_1;
+  // Inline function 'kotlin.getValue' call
+  _hashCode$factory();
+  return tmp0.s1();
+}
+function SerialDescriptorImpl$_hashCode$delegate$lambda(this$0) {
+  return () => hashCodeImpl(this$0, this$0.nq_1);
+}
+function SerialDescriptorImpl$toString$lambda(this$0) {
+  return (it) => this$0.up(it) + ': ' + this$0.vp(it).pp();
+}
+function buildClassSerialDescriptor(serialName, typeParameters, builderAction) {
+  var tmp;
+  if (builderAction === VOID) {
+    tmp = buildClassSerialDescriptor$lambda;
+  } else {
+    tmp = builderAction;
+  }
+  builderAction = tmp;
+  // Inline function 'kotlin.text.isNotBlank' call
+  // Inline function 'kotlin.require' call
+  if (!!isBlank(serialName)) {
+    // Inline function 'kotlinx.serialization.descriptors.buildClassSerialDescriptor.<anonymous>' call
+    var message = 'Blank serial names are prohibited';
+    throw IllegalArgumentException.s(toString(message));
+  }
+  var sdBuilder = new ClassSerialDescriptorBuilder(serialName);
+  builderAction(sdBuilder);
+  return new SerialDescriptorImpl(serialName, CLASS_getInstance(), sdBuilder.no_1.i1(), toList(typeParameters), sdBuilder);
+}
+function PrimitiveSerialDescriptor_0(serialName, kind) {
+  // Inline function 'kotlin.text.isNotBlank' call
+  // Inline function 'kotlin.require' call
+  if (!!isBlank(serialName)) {
+    // Inline function 'kotlinx.serialization.descriptors.PrimitiveSerialDescriptor.<anonymous>' call
+    var message = 'Blank serial names are prohibited';
+    throw IllegalArgumentException.s(toString(message));
+  }
+  return PrimitiveDescriptorSafe(serialName, kind);
+}
+function buildSerialDescriptor$lambda(_this__u8e3s4) {
+  return Unit_instance;
+}
+function buildClassSerialDescriptor$lambda(_this__u8e3s4) {
+  return Unit_instance;
+}
+function _hashCode$factory() {
+  return getPropertyCallableRef('_hashCode', 1, KProperty1, (receiver) => _get__hashCode__tgwhef(receiver), null);
+}
+var ENUM_instance;
+function ENUM_getInstance() {
+  if (ENUM_instance === VOID)
+    new ENUM();
+  return ENUM_instance;
+}
+var CONTEXTUAL_instance;
+function CONTEXTUAL_getInstance() {
+  if (CONTEXTUAL_instance === VOID)
+    new CONTEXTUAL();
+  return CONTEXTUAL_instance;
+}
+var OPEN_instance;
+function OPEN_getInstance() {
+  if (OPEN_instance === VOID)
+    new OPEN();
+  return OPEN_instance;
+}
+var BOOLEAN_instance;
+function BOOLEAN_getInstance() {
+  if (BOOLEAN_instance === VOID)
+    new BOOLEAN();
+  return BOOLEAN_instance;
+}
+var BYTE_instance;
+function BYTE_getInstance() {
+  if (BYTE_instance === VOID)
+    new BYTE();
+  return BYTE_instance;
+}
+var CHAR_instance;
+function CHAR_getInstance() {
+  if (CHAR_instance === VOID)
+    new CHAR();
+  return CHAR_instance;
+}
+var SHORT_instance;
+function SHORT_getInstance() {
+  if (SHORT_instance === VOID)
+    new SHORT();
+  return SHORT_instance;
+}
+var INT_instance;
+function INT_getInstance() {
+  if (INT_instance === VOID)
+    new INT();
+  return INT_instance;
+}
+var LONG_instance;
+function LONG_getInstance() {
+  if (LONG_instance === VOID)
+    new LONG();
+  return LONG_instance;
+}
+var FLOAT_instance;
+function FLOAT_getInstance() {
+  if (FLOAT_instance === VOID)
+    new FLOAT();
+  return FLOAT_instance;
+}
+var DOUBLE_instance;
+function DOUBLE_getInstance() {
+  if (DOUBLE_instance === VOID)
+    new DOUBLE();
+  return DOUBLE_instance;
+}
+var STRING_instance;
+function STRING_getInstance() {
+  if (STRING_instance === VOID)
+    new STRING();
+  return STRING_instance;
+}
+var CLASS_instance;
+function CLASS_getInstance() {
+  if (CLASS_instance === VOID)
+    new CLASS();
+  return CLASS_instance;
+}
+var LIST_instance;
+function LIST_getInstance() {
+  if (LIST_instance === VOID)
+    new LIST();
+  return LIST_instance;
+}
+var MAP_instance;
+function MAP_getInstance() {
+  if (MAP_instance === VOID)
+    new MAP();
+  return MAP_instance;
+}
+var OBJECT_instance;
+function OBJECT_getInstance() {
+  if (OBJECT_instance === VOID)
+    new OBJECT();
+  return OBJECT_instance;
+}
+function throwSubtypeNotRegistered(subClass, baseClass) {
+  var tmp0_elvis_lhs = subClass.ce();
+  throwSubtypeNotRegistered_0(tmp0_elvis_lhs == null ? toString(subClass) : tmp0_elvis_lhs, baseClass);
+}
+function throwSubtypeNotRegistered_0(subClassName, baseClass) {
+  var scope = "in the polymorphic scope of '" + baseClass.ce() + "'";
+  throw SerializationException.fp(subClassName == null ? 'Class discriminator was missing and no default serializers were registered ' + scope + '.' : "Serializer for subclass '" + subClassName + "' is not found " + scope + '.\n' + ("Check if class with serial name '" + subClassName + "' exists and serializer is registered in a corresponding SerializersModule.\n") + ("To be registered automatically, class '" + subClassName + "' has to be '@Serializable', and the base class '" + baseClass.ce() + "' has to be sealed and '@Serializable'."));
+}
+var NothingSerializer_instance;
+function NothingSerializer_getInstance() {
+  if (NothingSerializer_instance === VOID)
+    new NothingSerializer();
+  return NothingSerializer_instance;
+}
+var DurationSerializer_instance;
+function DurationSerializer_getInstance() {
+  if (DurationSerializer_instance === VOID)
+    new DurationSerializer();
+  return DurationSerializer_instance;
+}
+var UuidSerializer_instance;
+function UuidSerializer_getInstance() {
+  if (UuidSerializer_instance === VOID)
+    new UuidSerializer();
+  return UuidSerializer_instance;
+}
+function InlinePrimitiveDescriptor(name, primitiveSerializer) {
+  return new InlineClassDescriptor(name, new InlinePrimitiveDescriptor$1(primitiveSerializer));
+}
+function jsonCachedSerialNames(_this__u8e3s4) {
+  return cachedSerialNames(_this__u8e3s4);
+}
+var NoOpEncoder_instance;
+function NoOpEncoder_getInstance() {
+  if (NoOpEncoder_instance === VOID)
+    NoOpEncoder.iv();
+  return NoOpEncoder_instance;
+}
+function error($this) {
+  throw IllegalStateException.e4('Descriptor for type `kotlin.Nothing` does not have elements');
+}
+var NothingSerialDescriptor_instance;
+function NothingSerialDescriptor_getInstance() {
+  if (NothingSerialDescriptor_instance === VOID)
+    new NothingSerialDescriptor();
+  return NothingSerialDescriptor_instance;
+}
+function ObjectSerializer$descriptor$delegate$lambda$lambda(this$0) {
+  return ($this$buildSerialDescriptor) => {
+    $this$buildSerialDescriptor.mo_1 = this$0.pv_1;
+    return Unit_instance;
+  };
+}
+function ObjectSerializer$descriptor$delegate$lambda($serialName, this$0) {
+  return () => {
+    var tmp = OBJECT_getInstance();
+    return buildSerialDescriptor($serialName, tmp, [], ObjectSerializer$descriptor$delegate$lambda$lambda(this$0));
+  };
+}
+function descriptor$factory_1() {
+  return getPropertyCallableRef('descriptor', 1, KProperty1, (receiver) => receiver.io(), null);
+}
+function get_EMPTY_DESCRIPTOR_ARRAY() {
+  _init_properties_Platform_common_kt__3qzecs();
+  return EMPTY_DESCRIPTOR_ARRAY;
+}
+var EMPTY_DESCRIPTOR_ARRAY;
+function cachedSerialNames(_this__u8e3s4) {
+  _init_properties_Platform_common_kt__3qzecs();
+  if (isInterface(_this__u8e3s4, CachedNames))
+    return _this__u8e3s4.pq();
+  var result = HashSet.h1(_this__u8e3s4.sp());
+  var inductionVariable = 0;
+  var last = _this__u8e3s4.sp();
+  if (inductionVariable < last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.collections.plusAssign' call
+      var element = _this__u8e3s4.up(i);
+      result.o(element);
+    }
+     while (inductionVariable < last);
+  return result;
+}
+function kclass(_this__u8e3s4) {
+  _init_properties_Platform_common_kt__3qzecs();
+  var t = _this__u8e3s4.qe();
+  var tmp;
+  if (!(t == null) ? isInterface(t, KClass) : false) {
+    tmp = t;
+  } else {
+    if (!(t == null) ? isInterface(t, KTypeParameter) : false) {
+      throw IllegalArgumentException.s('Captured type parameter ' + toString(t) + ' from generic non-reified function. ' + ('Such functionality cannot be supported because ' + toString(t) + ' is erased, either specify serializer explicitly or make ') + ('calling function inline with reified ' + toString(t) + '.'));
+    } else {
+      throw IllegalArgumentException.s('Only KClass supported as classifier, got ' + toString_0(t));
+    }
+  }
+  var tmp_0 = tmp;
+  return isInterface(tmp_0, KClass) ? tmp_0 : THROW_CCE();
+}
+function typeOrThrow(_this__u8e3s4) {
+  _init_properties_Platform_common_kt__3qzecs();
+  var tmp0 = _this__u8e3s4.bl_1;
+  var tmp$ret$1;
+  $l$block: {
+    // Inline function 'kotlin.requireNotNull' call
+    if (tmp0 == null) {
+      // Inline function 'kotlinx.serialization.internal.typeOrThrow.<anonymous>' call
+      var message = 'Star projections in type arguments are not allowed, but had ' + toString_0(_this__u8e3s4.bl_1);
+      throw IllegalArgumentException.s(toString(message));
+    } else {
+      tmp$ret$1 = tmp0;
+      break $l$block;
+    }
+  }
+  return tmp$ret$1;
+}
+function notRegisteredMessage(_this__u8e3s4) {
+  _init_properties_Platform_common_kt__3qzecs();
+  var tmp0_elvis_lhs = _this__u8e3s4.ce();
+  return notRegisteredMessage_0(tmp0_elvis_lhs == null ? '<local class name not available>' : tmp0_elvis_lhs);
+}
+function compactArray(_this__u8e3s4) {
+  _init_properties_Platform_common_kt__3qzecs();
+  // Inline function 'kotlin.takeUnless' call
+  var tmp;
+  // Inline function 'kotlinx.serialization.internal.compactArray.<anonymous>' call
+  // Inline function 'kotlin.collections.isNullOrEmpty' call
+  if (!(_this__u8e3s4 == null || _this__u8e3s4.a1())) {
+    tmp = _this__u8e3s4;
+  } else {
+    tmp = null;
+  }
+  var tmp0_safe_receiver = tmp;
+  var tmp_0;
+  if (tmp0_safe_receiver == null) {
+    tmp_0 = null;
+  } else {
+    // Inline function 'kotlin.collections.toTypedArray' call
+    tmp_0 = copyToArray(tmp0_safe_receiver);
+  }
+  var tmp1_elvis_lhs = tmp_0;
+  return tmp1_elvis_lhs == null ? get_EMPTY_DESCRIPTOR_ARRAY() : tmp1_elvis_lhs;
+}
+function notRegisteredMessage_0(className) {
+  _init_properties_Platform_common_kt__3qzecs();
+  return "Serializer for class '" + className + "' is not found.\n" + "Please ensure that class is marked as '@Serializable' and that the serialization compiler plugin is applied.\n";
+}
+var properties_initialized_Platform_common_kt_i7q4ty;
+function _init_properties_Platform_common_kt__3qzecs() {
+  if (!properties_initialized_Platform_common_kt_i7q4ty) {
+    properties_initialized_Platform_common_kt_i7q4ty = true;
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    EMPTY_DESCRIPTOR_ARRAY = [];
+  }
+}
+function hashCodeImpl(_this__u8e3s4, typeParams) {
+  var result = getStringHashCode(_this__u8e3s4.pp());
+  result = imul(31, result) + contentHashCode(typeParams) | 0;
+  var elementDescriptors = get_elementDescriptors(_this__u8e3s4);
+  // Inline function 'kotlinx.serialization.internal.elementsHashCodeBy' call
+  // Inline function 'kotlin.collections.fold' call
+  var accumulator = 1;
+  var _iterator__ex2g4s = elementDescriptors.d1();
+  while (_iterator__ex2g4s.e1()) {
+    var element = _iterator__ex2g4s.f1();
+    // Inline function 'kotlinx.serialization.internal.elementsHashCodeBy.<anonymous>' call
+    var hash = accumulator;
+    var tmp = imul(31, hash);
+    // Inline function 'kotlinx.serialization.internal.hashCodeImpl.<anonymous>' call
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver = element.pp();
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+    accumulator = tmp + (tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs) | 0;
+  }
+  var namesHash = accumulator;
+  // Inline function 'kotlinx.serialization.internal.elementsHashCodeBy' call
+  // Inline function 'kotlin.collections.fold' call
+  var accumulator_0 = 1;
+  var _iterator__ex2g4s_0 = elementDescriptors.d1();
+  while (_iterator__ex2g4s_0.e1()) {
+    var element_0 = _iterator__ex2g4s_0.f1();
+    // Inline function 'kotlinx.serialization.internal.elementsHashCodeBy.<anonymous>' call
+    var hash_0 = accumulator_0;
+    var tmp_0 = imul(31, hash_0);
+    // Inline function 'kotlinx.serialization.internal.hashCodeImpl.<anonymous>' call
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver_0 = element_0.qp();
+    var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+    accumulator_0 = tmp_0 + (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0) | 0;
+  }
+  var kindHash = accumulator_0;
+  result = imul(31, result) + namesHash | 0;
+  result = imul(31, result) + kindHash | 0;
+  return result;
+}
+function _get_childSerializers__7vnyfa($this) {
+  var tmp0 = $this.zu_1;
+  // Inline function 'kotlin.getValue' call
+  childSerializers$factory();
+  return tmp0.s1();
+}
+function _get__hashCode__tgwhef_0($this) {
+  var tmp0 = $this.bv_1;
+  // Inline function 'kotlin.getValue' call
+  _hashCode$factory_0();
+  return tmp0.s1();
+}
+function buildIndices($this) {
+  var indices = HashMap.n7();
+  var inductionVariable = 0;
+  var last = $this.uu_1.length - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      // Inline function 'kotlin.collections.set' call
+      var key = $this.uu_1[i];
+      indices.x2(key, i);
+    }
+     while (inductionVariable <= last);
+  return indices;
+}
+function PluginGeneratedSerialDescriptor$childSerializers$delegate$lambda(this$0) {
+  return () => {
+    var tmp0_safe_receiver = this$0.ru_1;
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.fv();
+    return tmp1_elvis_lhs == null ? get_EMPTY_SERIALIZER_ARRAY() : tmp1_elvis_lhs;
+  };
+}
+function PluginGeneratedSerialDescriptor$typeParameterDescriptors$delegate$lambda(this$0) {
+  return () => {
+    var tmp0_safe_receiver = this$0.ru_1;
+    var tmp1_safe_receiver = tmp0_safe_receiver == null ? null : tmp0_safe_receiver.gv();
+    var tmp;
+    if (tmp1_safe_receiver == null) {
+      tmp = null;
+    } else {
+      // Inline function 'kotlin.collections.map' call
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList.k1(tmp1_safe_receiver.length);
+      var inductionVariable = 0;
+      var last = tmp1_safe_receiver.length;
+      while (inductionVariable < last) {
+        var item = tmp1_safe_receiver[inductionVariable];
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlinx.serialization.internal.PluginGeneratedSerialDescriptor.typeParameterDescriptors$delegate.<anonymous>.<anonymous>' call
+        var tmp$ret$0 = item.io();
+        destination.o(tmp$ret$0);
+      }
+      tmp = destination;
+    }
+    return compactArray(tmp);
+  };
+}
+function PluginGeneratedSerialDescriptor$_hashCode$delegate$lambda(this$0) {
+  return () => hashCodeImpl(this$0, this$0.cv());
+}
+function PluginGeneratedSerialDescriptor$toString$lambda(this$0) {
+  return (i) => this$0.up(i) + ': ' + this$0.vp(i).pp();
+}
+function childSerializers$factory() {
+  return getPropertyCallableRef('childSerializers', 1, KProperty1, (receiver) => _get_childSerializers__7vnyfa(receiver), null);
+}
+function typeParameterDescriptors$factory() {
+  return getPropertyCallableRef('typeParameterDescriptors', 1, KProperty1, (receiver) => receiver.cv(), null);
+}
+function _hashCode$factory_0() {
+  return getPropertyCallableRef('_hashCode', 1, KProperty1, (receiver) => _get__hashCode__tgwhef_0(receiver), null);
+}
+function get_EMPTY_SERIALIZER_ARRAY() {
+  _init_properties_PluginHelperInterfaces_kt__xgvzfp();
+  return EMPTY_SERIALIZER_ARRAY;
+}
+var EMPTY_SERIALIZER_ARRAY;
+var properties_initialized_PluginHelperInterfaces_kt_ap8in1;
+function _init_properties_PluginHelperInterfaces_kt__xgvzfp() {
+  if (!properties_initialized_PluginHelperInterfaces_kt_ap8in1) {
+    properties_initialized_PluginHelperInterfaces_kt_ap8in1 = true;
+    // Inline function 'kotlin.arrayOf' call
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    EMPTY_SERIALIZER_ARRAY = [];
+  }
+}
+var CharArraySerializer_instance;
+function CharArraySerializer_getInstance() {
+  if (CharArraySerializer_instance === VOID)
+    new CharArraySerializer();
+  return CharArraySerializer_instance;
+}
+var DoubleArraySerializer_instance;
+function DoubleArraySerializer_getInstance() {
+  if (DoubleArraySerializer_instance === VOID)
+    new DoubleArraySerializer();
+  return DoubleArraySerializer_instance;
+}
+var FloatArraySerializer_instance;
+function FloatArraySerializer_getInstance() {
+  if (FloatArraySerializer_instance === VOID)
+    new FloatArraySerializer();
+  return FloatArraySerializer_instance;
+}
+var LongArraySerializer_instance;
+function LongArraySerializer_getInstance() {
+  if (LongArraySerializer_instance === VOID)
+    new LongArraySerializer();
+  return LongArraySerializer_instance;
+}
+var ULongArraySerializer_instance;
+function ULongArraySerializer_getInstance() {
+  if (ULongArraySerializer_instance === VOID)
+    new ULongArraySerializer();
+  return ULongArraySerializer_instance;
+}
+var IntArraySerializer_instance;
+function IntArraySerializer_getInstance() {
+  if (IntArraySerializer_instance === VOID)
+    new IntArraySerializer();
+  return IntArraySerializer_instance;
+}
+var UIntArraySerializer_instance;
+function UIntArraySerializer_getInstance() {
+  if (UIntArraySerializer_instance === VOID)
+    new UIntArraySerializer();
+  return UIntArraySerializer_instance;
+}
+var ShortArraySerializer_instance;
+function ShortArraySerializer_getInstance() {
+  if (ShortArraySerializer_instance === VOID)
+    new ShortArraySerializer();
+  return ShortArraySerializer_instance;
+}
+var UShortArraySerializer_instance;
+function UShortArraySerializer_getInstance() {
+  if (UShortArraySerializer_instance === VOID)
+    new UShortArraySerializer();
+  return UShortArraySerializer_instance;
+}
+var ByteArraySerializer_instance;
+function ByteArraySerializer_getInstance() {
+  if (ByteArraySerializer_instance === VOID)
+    new ByteArraySerializer();
+  return ByteArraySerializer_instance;
+}
+var UByteArraySerializer_instance;
+function UByteArraySerializer_getInstance() {
+  if (UByteArraySerializer_instance === VOID)
+    new UByteArraySerializer();
+  return UByteArraySerializer_instance;
+}
+var BooleanArraySerializer_instance;
+function BooleanArraySerializer_getInstance() {
+  if (BooleanArraySerializer_instance === VOID)
+    new BooleanArraySerializer();
+  return BooleanArraySerializer_instance;
+}
+function get_BUILTIN_SERIALIZERS() {
+  _init_properties_Primitives_kt__k0eto4();
+  return BUILTIN_SERIALIZERS;
+}
+var BUILTIN_SERIALIZERS;
+function builtinSerializerOrNull(_this__u8e3s4) {
+  _init_properties_Primitives_kt__k0eto4();
+  var tmp = get_BUILTIN_SERIALIZERS().p2(_this__u8e3s4);
+  return (tmp == null ? true : isInterface(tmp, KSerializer)) ? tmp : THROW_CCE();
+}
+var StringSerializer_instance;
+function StringSerializer_getInstance() {
+  if (StringSerializer_instance === VOID)
+    new StringSerializer();
+  return StringSerializer_instance;
+}
+var CharSerializer_instance;
+function CharSerializer_getInstance() {
+  if (CharSerializer_instance === VOID)
+    new CharSerializer();
+  return CharSerializer_instance;
+}
+var DoubleSerializer_instance;
+function DoubleSerializer_getInstance() {
+  if (DoubleSerializer_instance === VOID)
+    new DoubleSerializer();
+  return DoubleSerializer_instance;
+}
+var FloatSerializer_instance;
+function FloatSerializer_getInstance() {
+  if (FloatSerializer_instance === VOID)
+    new FloatSerializer();
+  return FloatSerializer_instance;
+}
+var LongSerializer_instance;
+function LongSerializer_getInstance() {
+  if (LongSerializer_instance === VOID)
+    new LongSerializer();
+  return LongSerializer_instance;
+}
+var IntSerializer_instance;
+function IntSerializer_getInstance() {
+  if (IntSerializer_instance === VOID)
+    new IntSerializer();
+  return IntSerializer_instance;
+}
+var ShortSerializer_instance;
+function ShortSerializer_getInstance() {
+  if (ShortSerializer_instance === VOID)
+    new ShortSerializer();
+  return ShortSerializer_instance;
+}
+var ByteSerializer_instance;
+function ByteSerializer_getInstance() {
+  if (ByteSerializer_instance === VOID)
+    new ByteSerializer();
+  return ByteSerializer_instance;
+}
+var BooleanSerializer_instance;
+function BooleanSerializer_getInstance() {
+  if (BooleanSerializer_instance === VOID)
+    new BooleanSerializer();
+  return BooleanSerializer_instance;
+}
+var UnitSerializer_instance;
+function UnitSerializer_getInstance() {
+  if (UnitSerializer_instance === VOID)
+    new UnitSerializer();
+  return UnitSerializer_instance;
+}
+function error_0($this) {
+  throw IllegalStateException.e4('Primitive descriptor does not have elements');
+}
+function PrimitiveDescriptorSafe(serialName, kind) {
+  _init_properties_Primitives_kt__k0eto4();
+  checkName(serialName);
+  return new PrimitiveSerialDescriptor(serialName, kind);
+}
+function checkName(serialName) {
+  _init_properties_Primitives_kt__k0eto4();
+  var values = get_BUILTIN_SERIALIZERS().r2();
+  var _iterator__ex2g4s = values.d1();
+  while (_iterator__ex2g4s.e1()) {
+    var primitive = _iterator__ex2g4s.f1();
+    var primitiveName = primitive.io().pp();
+    if (serialName === primitiveName) {
+      throw IllegalArgumentException.s(trimIndent('\n                The name of serial descriptor should uniquely identify associated serializer.\n                For serial name ' + serialName + ' there already exists ' + getKClassFromExpression(primitive).ce() + '.\n                Please refer to SerialDescriptor documentation for additional information.\n            '));
+    }
+  }
+}
+var properties_initialized_Primitives_kt_6dpii6;
+function _init_properties_Primitives_kt__k0eto4() {
+  if (!properties_initialized_Primitives_kt_6dpii6) {
+    properties_initialized_Primitives_kt_6dpii6 = true;
+    BUILTIN_SERIALIZERS = initBuiltins();
+  }
+}
+function MapEntrySerializer$descriptor$lambda($keySerializer, $valueSerializer) {
+  return ($this$buildSerialDescriptor) => {
+    $this$buildSerialDescriptor.so('key', $keySerializer.io());
+    $this$buildSerialDescriptor.so('value', $valueSerializer.io());
+    return Unit_instance;
+  };
+}
+function PairSerializer$descriptor$lambda($keySerializer, $valueSerializer) {
+  return ($this$buildClassSerialDescriptor) => {
+    $this$buildClassSerialDescriptor.so('first', $keySerializer.io());
+    $this$buildClassSerialDescriptor.so('second', $valueSerializer.io());
+    return Unit_instance;
+  };
+}
+function TripleSerializer$descriptor$lambda(this$0) {
+  return ($this$buildClassSerialDescriptor) => {
+    $this$buildClassSerialDescriptor.so('first', this$0.zy_1.io());
+    $this$buildClassSerialDescriptor.so('second', this$0.az_1.io());
+    $this$buildClassSerialDescriptor.so('third', this$0.bz_1.io());
+    return Unit_instance;
+  };
+}
+var ULongSerializer_instance;
+function ULongSerializer_getInstance() {
+  if (ULongSerializer_instance === VOID)
+    new ULongSerializer();
+  return ULongSerializer_instance;
+}
+var UIntSerializer_instance;
+function UIntSerializer_getInstance() {
+  if (UIntSerializer_instance === VOID)
+    new UIntSerializer();
+  return UIntSerializer_instance;
+}
+var UShortSerializer_instance;
+function UShortSerializer_getInstance() {
+  if (UShortSerializer_instance === VOID)
+    new UShortSerializer();
+  return UShortSerializer_instance;
+}
+var UByteSerializer_instance;
+function UByteSerializer_getInstance() {
+  if (UByteSerializer_instance === VOID)
+    new UByteSerializer();
+  return UByteSerializer_instance;
+}
+function get_EmptySerializersModuleLegacyJs() {
+  _init_properties_SerializersModule_kt__u78ha3();
+  return EmptySerializersModule;
+}
+var EmptySerializersModule;
+var properties_initialized_SerializersModule_kt_fjigjn;
+function _init_properties_SerializersModule_kt__u78ha3() {
+  if (!properties_initialized_SerializersModule_kt_fjigjn) {
+    properties_initialized_SerializersModule_kt_fjigjn = true;
+    EmptySerializersModule = new SerialModuleImpl(emptyMap(), emptyMap(), emptyMap(), emptyMap(), emptyMap(), false);
+  }
+}
+function EmptySerializersModule_0() {
+  return get_EmptySerializersModuleLegacyJs();
+}
+function createCache(factory) {
+  return new createCache$1(factory);
+}
+function createParametrizedCache(factory) {
+  return new createParametrizedCache$1(factory);
+}
+function isInterface_0(_this__u8e3s4) {
+  return get_isInterface(_this__u8e3s4);
+}
+function initBuiltins() {
+  return mapOf([to(PrimitiveClasses_getInstance().df(), serializer_0(StringCompanionObject_instance)), to(getKClass(Char), serializer_1(Companion_getInstance())), to(PrimitiveClasses_getInstance().gf(), CharArraySerializer_0()), to(PrimitiveClasses_getInstance().bf(), serializer_2(DoubleCompanionObject_instance)), to(PrimitiveClasses_getInstance().mf(), DoubleArraySerializer_0()), to(PrimitiveClasses_getInstance().af(), serializer_3(FloatCompanionObject_instance)), to(PrimitiveClasses_getInstance().lf(), FloatArraySerializer_0()), to(getKClass(Long), serializer_4(Companion_getInstance_0())), to(PrimitiveClasses_getInstance().kf(), LongArraySerializer_0()), to(getKClass(ULong), serializer_5(Companion_getInstance_1())), to(getKClass(ULongArray), ULongArraySerializer_0()), to(PrimitiveClasses_getInstance().ze(), serializer_6(IntCompanionObject_instance)), to(PrimitiveClasses_getInstance().jf(), IntArraySerializer_0()), to(getKClass(UInt), serializer_7(Companion_getInstance_2())), to(getKClass(UIntArray), UIntArraySerializer_0()), to(PrimitiveClasses_getInstance().ye(), serializer_8(ShortCompanionObject_instance)), to(PrimitiveClasses_getInstance().if(), ShortArraySerializer_0()), to(getKClass(UShort), serializer_9(Companion_getInstance_3())), to(getKClass(UShortArray), UShortArraySerializer_0()), to(PrimitiveClasses_getInstance().xe(), serializer_10(ByteCompanionObject_instance)), to(PrimitiveClasses_getInstance().hf(), ByteArraySerializer_0()), to(getKClass(UByte), serializer_11(Companion_getInstance_4())), to(getKClass(UByteArray), UByteArraySerializer_0()), to(PrimitiveClasses_getInstance().we(), serializer_12(BooleanCompanionObject_instance)), to(PrimitiveClasses_getInstance().ff(), BooleanArraySerializer_0()), to(getKClass(Unit), serializer_13(Unit_instance)), to(PrimitiveClasses_getInstance().ve(), NothingSerializer_0()), to(getKClass(Duration), serializer_14(Companion_getInstance_5())), to(getKClass(Uuid), serializer_15(Companion_getInstance_6()))]);
+}
+function get_isInterface(_this__u8e3s4) {
+  if (_this__u8e3s4 === PrimitiveClasses_getInstance().ve())
+    return false;
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp0_safe_receiver = get_js(_this__u8e3s4).$metadata$;
+  return (tmp0_safe_receiver == null ? null : tmp0_safe_receiver.kind) == 'interface';
+}
+function compiledSerializerImpl(_this__u8e3s4) {
+  var tmp0_elvis_lhs = constructSerializerForGivenTypeArgs(_this__u8e3s4, []);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    var tmp_0;
+    if (_this__u8e3s4 === PrimitiveClasses_getInstance().ve()) {
+      tmp_0 = NothingSerializer_getInstance();
+    } else {
+      // Inline function 'kotlin.js.asDynamic' call
+      var tmp1_safe_receiver = get_js(_this__u8e3s4).Companion;
+      tmp_0 = tmp1_safe_receiver == null ? null : tmp1_safe_receiver.serializer();
+    }
+    var tmp_1 = tmp_0;
+    tmp = (!(tmp_1 == null) ? isInterface(tmp_1, KSerializer) : false) ? tmp_1 : null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+function platformSpecificSerializerNotRegistered(_this__u8e3s4) {
+  throw SerializationException.fp(notRegisteredMessage(_this__u8e3s4) + 'To get enum serializer on Kotlin/JS, it should be annotated with @Serializable annotation.');
+}
+function isReferenceArray(rootClass) {
+  return rootClass.equals(PrimitiveClasses_getInstance().cf());
+}
+function constructSerializerForGivenTypeArgs(_this__u8e3s4, args) {
+  var tmp;
+  try {
+    // Inline function 'kotlin.reflect.findAssociatedObject' call
+    var assocObject = findAssociatedObject(_this__u8e3s4, getKClass(SerializableWith));
+    var tmp_0;
+    if (!(assocObject == null) ? isInterface(assocObject, KSerializer) : false) {
+      tmp_0 = isInterface(assocObject, KSerializer) ? assocObject : THROW_CCE();
+    } else {
+      if (!(assocObject == null) ? isInterface(assocObject, SerializerFactory) : false) {
+        var tmp_1 = assocObject.rv(args.slice());
+        tmp_0 = isInterface(tmp_1, KSerializer) ? tmp_1 : THROW_CCE();
+      } else {
+        tmp_0 = null;
+      }
+    }
+    tmp = tmp_0;
+  } catch ($p) {
+    var tmp_2;
+    var e = $p;
+    tmp_2 = null;
+    tmp = tmp_2;
+  }
+  return tmp;
+}
+function getChecked(_this__u8e3s4, index) {
+  if (!(0 <= index ? index <= (_this__u8e3s4.length - 1 | 0) : false))
+    throw IndexOutOfBoundsException.gd('Index ' + index + ' out of bounds ' + get_indices(_this__u8e3s4).toString());
+  return _this__u8e3s4[index];
+}
+//region block: post-declaration
+initMetadataForInterface(SerializationStrategy, 'SerializationStrategy');
+initMetadataForInterface(KSerializer, 'KSerializer', VOID, VOID, [SerializationStrategy]);
+initMetadataForClass(AbstractPolymorphicSerializer, 'AbstractPolymorphicSerializer', VOID, VOID, [KSerializer]);
+initMetadataForClass(PolymorphicSerializer, 'PolymorphicSerializer');
+initMetadataForClass(SealedClassSerializer, 'SealedClassSerializer');
+initMetadataForClass(SerializationException, 'SerializationException', SerializationException.ep);
+initMetadataForInterface(SerialDescriptor, 'SerialDescriptor');
+initMetadataForClass(ContextDescriptor, 'ContextDescriptor', VOID, VOID, [SerialDescriptor]);
+initMetadataForClass(elementDescriptors$1);
+initMetadataForClass(elementDescriptors$$inlined$Iterable$1);
+initMetadataForClass(ClassSerialDescriptorBuilder, 'ClassSerialDescriptorBuilder');
+initMetadataForInterface(CachedNames, 'CachedNames');
+protoOf(SerialDescriptorImpl).lp = get_isNullable;
+protoOf(SerialDescriptorImpl).rp = get_isInline;
+initMetadataForClass(SerialDescriptorImpl, 'SerialDescriptorImpl', VOID, VOID, [SerialDescriptor, CachedNames]);
+initMetadataForClass(SerialKind, 'SerialKind');
+initMetadataForObject(ENUM, 'ENUM');
+initMetadataForObject(CONTEXTUAL, 'CONTEXTUAL');
+initMetadataForClass(PolymorphicKind, 'PolymorphicKind');
+initMetadataForObject(OPEN, 'OPEN');
+initMetadataForClass(PrimitiveKind, 'PrimitiveKind');
+initMetadataForObject(BOOLEAN, 'BOOLEAN');
+initMetadataForObject(BYTE, 'BYTE');
+initMetadataForObject(CHAR, 'CHAR');
+initMetadataForObject(SHORT, 'SHORT');
+initMetadataForObject(INT, 'INT');
+initMetadataForObject(LONG, 'LONG');
+initMetadataForObject(FLOAT, 'FLOAT');
+initMetadataForObject(DOUBLE, 'DOUBLE');
+initMetadataForObject(STRING, 'STRING');
+initMetadataForClass(StructureKind, 'StructureKind');
+initMetadataForObject(CLASS, 'CLASS');
+initMetadataForObject(LIST, 'LIST');
+initMetadataForObject(MAP, 'MAP');
+initMetadataForObject(OBJECT, 'OBJECT');
+initMetadataForInterface(Encoder, 'Encoder');
+initMetadataForInterface(CompositeEncoder, 'CompositeEncoder');
+protoOf(AbstractEncoder).vr = encodeNotNullMark;
+protoOf(AbstractEncoder).wr = beginCollection;
+protoOf(AbstractEncoder).rr = encodeSerializableValue;
+protoOf(AbstractEncoder).tr = encodeNullableSerializableValue;
+protoOf(AbstractEncoder).xr = shouldEncodeElementDefault;
+initMetadataForClass(AbstractEncoder, 'AbstractEncoder', VOID, VOID, [Encoder, CompositeEncoder]);
+initMetadataForObject(NothingSerializer, 'NothingSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(DurationSerializer, 'DurationSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(UuidSerializer, 'UuidSerializer', VOID, VOID, [KSerializer]);
+protoOf(ListLikeDescriptor).lp = get_isNullable;
+protoOf(ListLikeDescriptor).rp = get_isInline;
+protoOf(ListLikeDescriptor).tp = get_annotations;
+initMetadataForClass(ListLikeDescriptor, 'ListLikeDescriptor', VOID, VOID, [SerialDescriptor]);
+initMetadataForClass(ArrayListClassDesc, 'ArrayListClassDesc');
+initMetadataForClass(HashSetClassDesc, 'HashSetClassDesc');
+initMetadataForClass(LinkedHashSetClassDesc, 'LinkedHashSetClassDesc');
+protoOf(MapLikeDescriptor).lp = get_isNullable;
+protoOf(MapLikeDescriptor).rp = get_isInline;
+protoOf(MapLikeDescriptor).tp = get_annotations;
+initMetadataForClass(MapLikeDescriptor, 'MapLikeDescriptor', VOID, VOID, [SerialDescriptor]);
+initMetadataForClass(HashMapClassDesc, 'HashMapClassDesc');
+initMetadataForClass(LinkedHashMapClassDesc, 'LinkedHashMapClassDesc');
+initMetadataForClass(ArrayClassDesc, 'ArrayClassDesc');
+initMetadataForClass(PrimitiveArrayDescriptor, 'PrimitiveArrayDescriptor');
+initMetadataForClass(AbstractCollectionSerializer, 'AbstractCollectionSerializer', VOID, VOID, [KSerializer]);
+initMetadataForClass(CollectionLikeSerializer, 'CollectionLikeSerializer');
+initMetadataForClass(CollectionSerializer, 'CollectionSerializer');
+initMetadataForClass(ArrayListSerializer, 'ArrayListSerializer');
+initMetadataForClass(HashSetSerializer, 'HashSetSerializer');
+initMetadataForClass(LinkedHashSetSerializer, 'LinkedHashSetSerializer');
+initMetadataForClass(MapLikeSerializer, 'MapLikeSerializer');
+initMetadataForClass(HashMapSerializer, 'HashMapSerializer');
+initMetadataForClass(LinkedHashMapSerializer, 'LinkedHashMapSerializer');
+initMetadataForClass(ReferenceArraySerializer, 'ReferenceArraySerializer');
+initMetadataForClass(PrimitiveArraySerializer, 'PrimitiveArraySerializer');
+protoOf(PluginGeneratedSerialDescriptor).lp = get_isNullable;
+protoOf(PluginGeneratedSerialDescriptor).rp = get_isInline;
+initMetadataForClass(PluginGeneratedSerialDescriptor, 'PluginGeneratedSerialDescriptor', VOID, VOID, [SerialDescriptor, CachedNames]);
+initMetadataForClass(InlineClassDescriptor, 'InlineClassDescriptor');
+initMetadataForInterface(GeneratedSerializer, 'GeneratedSerializer', VOID, VOID, [KSerializer]);
+protoOf(InlinePrimitiveDescriptor$1).gv = typeParametersSerializers;
+initMetadataForClass(InlinePrimitiveDescriptor$1, VOID, VOID, VOID, [GeneratedSerializer]);
+initMetadataForObject(NoOpEncoder, 'NoOpEncoder');
+protoOf(NothingSerialDescriptor).lp = get_isNullable;
+protoOf(NothingSerialDescriptor).rp = get_isInline;
+protoOf(NothingSerialDescriptor).tp = get_annotations;
+initMetadataForObject(NothingSerialDescriptor, 'NothingSerialDescriptor', VOID, VOID, [SerialDescriptor]);
+initMetadataForClass(NullableSerializer, 'NullableSerializer', VOID, VOID, [KSerializer]);
+initMetadataForClass(SerialDescriptorForNullable, 'SerialDescriptorForNullable', VOID, VOID, [SerialDescriptor, CachedNames]);
+initMetadataForClass(ObjectSerializer, 'ObjectSerializer', VOID, VOID, [KSerializer]);
+initMetadataForInterface(SerializerFactory, 'SerializerFactory');
+initMetadataForObject(CharArraySerializer, 'CharArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(DoubleArraySerializer, 'DoubleArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(FloatArraySerializer, 'FloatArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(LongArraySerializer, 'LongArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(ULongArraySerializer, 'ULongArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(IntArraySerializer, 'IntArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(UIntArraySerializer, 'UIntArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(ShortArraySerializer, 'ShortArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(UShortArraySerializer, 'UShortArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(ByteArraySerializer, 'ByteArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(UByteArraySerializer, 'UByteArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(BooleanArraySerializer, 'BooleanArraySerializer', VOID, VOID, [KSerializer, PrimitiveArraySerializer]);
+initMetadataForObject(StringSerializer, 'StringSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(CharSerializer, 'CharSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(DoubleSerializer, 'DoubleSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(FloatSerializer, 'FloatSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(LongSerializer, 'LongSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(IntSerializer, 'IntSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(ShortSerializer, 'ShortSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(ByteSerializer, 'ByteSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(BooleanSerializer, 'BooleanSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(UnitSerializer, 'UnitSerializer', VOID, VOID, [KSerializer]);
+protoOf(PrimitiveSerialDescriptor).lp = get_isNullable;
+protoOf(PrimitiveSerialDescriptor).rp = get_isInline;
+protoOf(PrimitiveSerialDescriptor).tp = get_annotations;
+initMetadataForClass(PrimitiveSerialDescriptor, 'PrimitiveSerialDescriptor', VOID, VOID, [SerialDescriptor]);
+initMetadataForClass(KeyValueSerializer, 'KeyValueSerializer', VOID, VOID, [KSerializer]);
+initMetadataForClass(MapEntrySerializer, 'MapEntrySerializer');
+initMetadataForClass(PairSerializer, 'PairSerializer');
+initMetadataForClass(TripleSerializer, 'TripleSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(ULongSerializer, 'ULongSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(UIntSerializer, 'UIntSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(UShortSerializer, 'UShortSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(UByteSerializer, 'UByteSerializer', VOID, VOID, [KSerializer]);
+initMetadataForClass(SerializersModule, 'SerializersModule');
+initMetadataForClass(SerialModuleImpl, 'SerialModuleImpl');
+initMetadataForClass(SerializableWith, 'SerializableWith', VOID, VOID, VOID, VOID, 0);
+initMetadataForClass(createCache$1);
+initMetadataForClass(createParametrizedCache$1);
+//endregion
+//region block: exports
+export {
+  STRING_getInstance as STRING_getInstance2u10xjygh5c7g,
+  CONTEXTUAL_getInstance as CONTEXTUAL_getInstance27x7ixba5zfl1,
+  ENUM_getInstance as ENUM_getInstance2pzy56ztbjm7u,
+  CLASS_getInstance as CLASS_getInstance277avqnuimd98,
+  LIST_getInstance as LIST_getInstance33zrks0ni9s1a,
+  MAP_getInstance as MAP_getInstance1g2gf9ptr5kcu,
+  OBJECT_getInstance as OBJECT_getInstanceb5uv07b4zkes,
+  IntSerializer_getInstance as IntSerializer_getInstance1qqxumiddm0tw,
+  StringSerializer_getInstance as StringSerializer_getInstance2kpn94uehvuc4,
+  get_nullable as get_nullable197rfua9r7fsz,
+  serializer_0 as serializer1x79l67jvwntn,
+  serializer_9 as serializer1q7c5q67ysppr,
+  serializer_7 as serializer3ikrxnm8b29d6,
+  serializer_11 as serializer36584sjyg5661,
+  serializer_5 as serializer2lw83vwvpnyms,
+  PolymorphicKind as PolymorphicKindla9gurooefwb,
+  PrimitiveKind as PrimitiveKindndgbuh6is7ze,
+  PrimitiveSerialDescriptor_0 as PrimitiveSerialDescriptor3egfp53lutxj2,
+  ENUM as ENUMlmq49cvwy4ow,
+  getContextualDescriptor as getContextualDescriptor2n1gf3b895yb8,
+  AbstractEncoder as AbstractEncoder2gxtu3xmy3f8j,
+  CompositeEncoder as CompositeEncoderknecpkexzn3v,
+  Encoder as Encoderqvmrpqtq8hnu,
+  AbstractPolymorphicSerializer as AbstractPolymorphicSerializer1ccxwp48nfy58,
+  ArrayListSerializer as ArrayListSerializer7k5wnrulb3y6,
+  typeParametersSerializers as typeParametersSerializers2likxjr48tr7y,
+  GeneratedSerializer as GeneratedSerializer1f7t7hssdd2ws,
+  InlinePrimitiveDescriptor as InlinePrimitiveDescriptor3i6ccn1a4fw94,
+  PluginGeneratedSerialDescriptor as PluginGeneratedSerialDescriptorqdzeg5asqhfg,
+  jsonCachedSerialNames as jsonCachedSerialNameslxufy2gu43jt,
+  EmptySerializersModule_0 as EmptySerializersModule991ju6pz9b79,
+  KSerializer as KSerializerzf77vz1967fq,
+  SealedClassSerializer as SealedClassSerializeriwipiibk55zc,
+  SerializationException as SerializationExceptioneqrdve3ts2n9,
+  SerializationStrategy as SerializationStrategyh6ouydnm6hci,
+  findPolymorphicSerializer as findPolymorphicSerializerk638ixyjovk5,
+  serializer as serializer1i4e9ym37oxmo,
+};
+//endregion
+
+//# sourceMappingURL=kotlinx-serialization-kotlinx-serialization-core.mjs.map