@solibo/home-api 1.1.9 → 1.1.10

package/Kotlin-DateTime-library-kotlinx-datetime.mjs

@@ -0,0 +1,3601 @@
+import {
+  protoOf180f3jzyo7rfj as protoOf,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  toString1pkumu07cwy4m as toString,
+  IllegalArgumentException_init_$Create$1j1aj36nbo0wg as IllegalArgumentException_init_$Create$,
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  fromInt2ii0rejb1w62w as fromInt,
+  modulooi4g1kq3dmtt as modulo,
+  dividelr0uqtdj497z as divide,
+  convertToInty04h231mmjoh as convertToInt,
+  shiftRight2gqph14wydb8s as shiftRight,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  VOID3gxj6tk5isa35 as VOID,
+  enumEntries20mr21zbe3az4 as enumEntries,
+  Enum3alwj03lh1n41 as Enum,
+  IllegalArgumentException_init_$Init$2okypt6yqrxs0 as IllegalArgumentException_init_$Init$,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+  captureStack1fzi4aczwc4hg as captureStack,
+  IllegalArgumentException_init_$Init$36j4g3r1a2ezi as IllegalArgumentException_init_$Init$_0,
+  IllegalArgumentException_init_$Init$1p7w1dj600dvq as IllegalArgumentException_init_$Init$_1,
+  IllegalArgumentException2asla15b5jaob as IllegalArgumentException,
+  RuntimeException_init_$Init$1acxq2g1g5gzr as RuntimeException_init_$Init$,
+  RuntimeException_init_$Init$p7pf7j2lj7nl as RuntimeException_init_$Init$_0,
+  RuntimeException1r3t0zl97011n as RuntimeException,
+  StringBuilder_init_$Create$322n630qt3r8c as StringBuilder_init_$Create$,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  toString3dhdjl9yf50de as toString_0,
+  KProperty02ce7r476m8633 as KProperty0,
+  getPropertyCallableRef3hckxc0xueiaj as getPropertyCallableRef,
+  hashCodeq5arwsb9dgti as hashCode,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  KMutableProperty11e8g1gb0ecb9j as KMutableProperty1,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
+  lazy2hsh8ze7j6ikd as lazy,
+  getBooleanHashCode1bbj3u6b3v0a7 as getBooleanHashCode,
+  ArrayList_init_$Create$1jemgvhi5v0js as ArrayList_init_$Create$,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  isInterface3d6p8outrmvmk as isInterface,
+  equals2au1ep9vhcato as equals,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+  toString30pk9tzaqopn as toString_1,
+  getStringHashCode26igk1bx568vk as getStringHashCode,
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charCodeAt1yspne1d8erbm as charCodeAt,
+  substringiqarkczpya5m as substring,
+  listOfvhqybd2zx248 as listOf,
+  substring3saq8ornu0luv as substring_0,
+  get_lastIndexld83bqhfgcdd as get_lastIndex,
+  emptyList1g2z5xcrvp2zy as emptyList,
+  joinToString1cxrrlmo0chqs as joinToString,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$3ivpeip4ouddx as ArrayList_init_$Create$_0,
+  singleo93pzdgfc557 as single,
+  abs1kdzbjes1idip as abs,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+  numberRangeToNumber25vse2rgp6rs8 as numberRangeToNumber,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  mutableListOf6oorvk2mtdmp as mutableListOf,
+  removeLastOrNull3odnlbetbttd4 as removeLastOrNull,
+  sortWith4fnm6b3vw03s as sortWith,
+  FunctionAdapter3lcrrz3moet5b as FunctionAdapter,
+  Comparator2b3maoeh98xtg as Comparator,
+  compareValues1n2ayl87ihzfk as compareValues,
+  Exceptiondt2hlxn7j7vw as Exception,
+  Exception_init_$Init$2jymvyiuv5u42 as Exception_init_$Init$,
+  StringBuilder_init_$Create$39ouzl6b47q8d as StringBuilder_init_$Create$_0,
+  joinTo3lkanfaxbzac2 as joinTo,
+  plus310ted5e4i90h as plus,
+  toMutableList20rdgwi7d3cwi as toMutableList,
+  addAll1k27qatfgp3k5 as addAll,
+  Collection1k04j3hzsbod0 as Collection,
+  firstOrNull1982767dljvdy as firstOrNull,
+  drop3na99dw9feawf as drop,
+  listOf1jh22dvmctj1r as listOf_0,
+  repeat2w4c6j8zoq09o as repeat,
+  checkCountOverflow1ro2fe1r4xvgf as checkCountOverflow,
+  Char__minus_impl_a2frrh1dka2ec6zg6dk as Char__minus_impl_a2frrh,
+  PrimitiveClasses_getInstance6p7zmos9nw3c as PrimitiveClasses_getInstance,
+  arrayOf1akklvh2at202 as arrayOf,
+  createKType31ecntyyaay3k as createKType,
+  LazyThreadSafetyMode_PUBLICATION_getInstance1vspt3xrdob1a as LazyThreadSafetyMode_PUBLICATION_getInstance,
+  lazy1261dae0bgscp as lazy_0,
+  KProperty1ca4yb4wlo496 as KProperty1,
+  getKClass3t8tygqu4lcxf as getKClass,
+  add2suhfggl4zvkk as add,
+  subtract2orl8z9upxd9l as subtract,
+  multiply2k9eolhnz1bjv as multiply,
+  negate13xrbakfwasjy as negate,
+  numberToLong2pakxeg38estk as numberToLong,
+  get_ONEazvfdh9ju3d4 as get_ONE,
+  compareTo3ankvs086tmwq as compareTo,
+  ClosedRangehokgr73im9z3 as ClosedRange,
+  contains2c50nlxg7en7o as contains,
+  Comparable198qfk8pnblz0 as Comparable,
+  ArithmeticException18dajwq7kbp38 as ArithmeticException,
+  compareValuesBy2ycqeh37x2wfm as compareValuesBy,
+  ArithmeticException_init_$Create$cn5qj1knrk0v as ArithmeticException_init_$Create$,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  buildClassSerialDescriptors2a6xdp6mrtw as buildClassSerialDescriptor,
+  serializer1hwzc6m64v1op as serializer,
+  KSerializerzf77vz1967fq as KSerializer,
+  MissingFieldException_init_$Create$1jct868unfeq5 as MissingFieldException_init_$Create$,
+  SealedClassSerializeriwipiibk55zc as SealedClassSerializer,
+  AbstractPolymorphicSerializer1ccxwp48nfy58 as AbstractPolymorphicSerializer,
+  SerializationException_init_$Create$2gf2fbfh3gfxm as SerializationException_init_$Create$,
+  STRING_getInstance2dgfp43qdvxn4 as STRING_getInstance,
+  PrimitiveSerialDescriptor3egfp53lutxj2 as PrimitiveSerialDescriptor,
+} from './kotlinx-serialization-kotlinx-serialization-core.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+initMetadataForCompanion(Companion);
+initMetadataForCompanion(Companion_0);
+initMetadataForCompanion(Companion_1);
+initMetadataForCompanion(Companion_2);
+initMetadataForClass(DateTimeUnit, 'DateTimeUnit', VOID, VOID, VOID, VOID, VOID, {0: DateTimeUnitSerializer_getInstance});
+initMetadataForClass(TimeBased, 'TimeBased', VOID, DateTimeUnit, VOID, VOID, VOID, {0: TimeBasedDateTimeUnitSerializer_getInstance});
+initMetadataForClass(DateBased, 'DateBased', VOID, DateTimeUnit, VOID, VOID, VOID, {0: DateBasedDateTimeUnitSerializer_getInstance});
+initMetadataForClass(DayBased, 'DayBased', VOID, DateBased, VOID, VOID, VOID, {0: DayBasedDateTimeUnitSerializer_getInstance});
+initMetadataForClass(MonthBased, 'MonthBased', VOID, DateBased, VOID, VOID, VOID, {0: MonthBasedDateTimeUnitSerializer_getInstance});
+initMetadataForCompanion(Companion_3);
+initMetadataForClass(DayOfWeek, 'DayOfWeek', VOID, Enum);
+initMetadataForClass(DateTimeFormatException, 'DateTimeFormatException', DateTimeFormatException_init_$Create$, IllegalArgumentException);
+initMetadataForClass(DateTimeArithmeticException, 'DateTimeArithmeticException', DateTimeArithmeticException_init_$Create$, RuntimeException);
+initMetadataForClass(Month, 'Month', VOID, Enum);
+initMetadataForClass(AbstractDateTimeFormat, 'AbstractDateTimeFormat');
+initMetadataForClass(Padding, 'Padding', VOID, Enum);
+function year$default(padding, $super) {
+  padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+  var tmp;
+  if ($super === VOID) {
+    this.z54(padding);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.z54.call(this, padding);
+  }
+  return tmp;
+}
+function monthNumber$default(padding, $super) {
+  padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+  var tmp;
+  if ($super === VOID) {
+    this.b55(padding);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.b55.call(this, padding);
+  }
+  return tmp;
+}
+initMetadataForInterface(WithYearMonth, 'WithYearMonth');
+function day$default(padding, $super) {
+  padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+  var tmp;
+  if ($super === VOID) {
+    this.e55(padding);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.e55.call(this, padding);
+  }
+  return tmp;
+}
+initMetadataForInterface(WithDate, 'WithDate', VOID, VOID, [WithYearMonth]);
+function chars(value) {
+  return this.g55().i55(new ConstantFormatStructure(value));
+}
+function build() {
+  return new CachedFormatStructure(this.g55().i2l().j55_1);
+}
+initMetadataForInterface(AbstractDateTimeFormatBuilder, 'AbstractDateTimeFormatBuilder');
+initMetadataForClass(IncompleteLocalDate, 'IncompleteLocalDate', IncompleteLocalDate);
+initMetadataForCompanion(Companion_4);
+function year(padding) {
+  return this.k56(new BasicFormatStructure(new YearDirective(padding)));
+}
+function monthNumber(padding) {
+  return this.k56(new BasicFormatStructure(new MonthDirective(padding)));
+}
+initMetadataForInterface(AbstractWithYearMonthBuilder, 'AbstractWithYearMonthBuilder', VOID, VOID, [WithYearMonth]);
+function addFormatStructureForYearMonth(structure) {
+  this.j56(structure);
+}
+function day(padding) {
+  return this.j56(new BasicFormatStructure(new DayDirective(padding)));
+}
+initMetadataForInterface(AbstractWithDateBuilder, 'AbstractWithDateBuilder', VOID, VOID, [AbstractWithYearMonthBuilder, WithDate]);
+initMetadataForClass(Builder, 'Builder', VOID, VOID, [AbstractDateTimeFormatBuilder, AbstractWithDateBuilder]);
+initMetadataForClass(LocalDateFormat, 'LocalDateFormat', VOID, AbstractDateTimeFormat);
+initMetadataForClass(UnsignedIntFieldFormatDirective, 'UnsignedIntFieldFormatDirective');
+initMetadataForClass(DayDirective, 'DayDirective', VOID, UnsignedIntFieldFormatDirective);
+initMetadataForObject(DateFields, 'DateFields');
+initMetadataForClass(IncompleteYearMonth, 'IncompleteYearMonth', IncompleteYearMonth);
+initMetadataForCompanion(Companion_5);
+initMetadataForClass(Builder_0, 'Builder', VOID, VOID, [AbstractDateTimeFormatBuilder, AbstractWithYearMonthBuilder]);
+initMetadataForClass(YearMonthFormat, 'YearMonthFormat', VOID, AbstractDateTimeFormat);
+initMetadataForClass(SignedIntFieldFormatDirective, 'SignedIntFieldFormatDirective');
+initMetadataForClass(YearDirective, 'YearDirective', VOID, SignedIntFieldFormatDirective);
+initMetadataForClass(MonthDirective, 'MonthDirective', VOID, UnsignedIntFieldFormatDirective);
+initMetadataForObject(YearMonthFields, 'YearMonthFields');
+initMetadataForClass(AppendableFormatStructure, 'AppendableFormatStructure', AppendableFormatStructure);
+initMetadataForClass(AbstractFieldSpec, 'AbstractFieldSpec');
+initMetadataForClass(GenericFieldSpec, 'GenericFieldSpec', VOID, AbstractFieldSpec);
+function getterNotNull(container) {
+  var tmp0_elvis_lhs = this.u58(container);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    throw IllegalStateException_init_$Create$('Field ' + this.m() + ' is not set');
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  return tmp;
+}
+initMetadataForInterface(Accessor, 'Accessor');
+initMetadataForClass(PropertyAccessor, 'PropertyAccessor', VOID, VOID, [Accessor]);
+initMetadataForClass(UnsignedFieldSpec, 'UnsignedFieldSpec', VOID, AbstractFieldSpec);
+initMetadataForClass(ConcatenatedFormatStructure, 'ConcatenatedFormatStructure');
+initMetadataForClass(CachedFormatStructure, 'CachedFormatStructure', VOID, ConcatenatedFormatStructure);
+initMetadataForInterface(NonConcatenatedFormatStructure, 'NonConcatenatedFormatStructure');
+initMetadataForClass(BasicFormatStructure, 'BasicFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure]);
+initMetadataForClass(ConstantFormatStructure, 'ConstantFormatStructure', VOID, VOID, [NonConcatenatedFormatStructure]);
+function format$default(obj, builder, minusNotRequired, $super) {
+  minusNotRequired = minusNotRequired === VOID ? false : minusNotRequired;
+  var tmp;
+  if ($super === VOID) {
+    this.x58(obj, builder, minusNotRequired);
+    tmp = Unit_instance;
+  } else {
+    tmp = $super.x58.call(this, obj, builder, minusNotRequired);
+  }
+  return tmp;
+}
+initMetadataForInterface(FormatterStructure, 'FormatterStructure');
+initMetadataForClass(SpacePaddedFormatter, 'SpacePaddedFormatter', VOID, VOID, [FormatterStructure]);
+initMetadataForClass(ConcatenatedFormatter, 'ConcatenatedFormatter', VOID, VOID, [FormatterStructure]);
+initMetadataForClass(UnsignedIntFormatterStructure, 'UnsignedIntFormatterStructure', VOID, VOID, [FormatterStructure]);
+initMetadataForClass(SignedIntFormatterStructure, 'SignedIntFormatterStructure', VOID, VOID, [FormatterStructure]);
+initMetadataForClass(ConstantStringFormatterStructure, 'ConstantStringFormatterStructure', VOID, VOID, [FormatterStructure]);
+initMetadataForClass(NumberConsumer, 'NumberConsumer');
+initMetadataForClass(ConstantNumberConsumer, 'ConstantNumberConsumer', VOID, NumberConsumer);
+initMetadataForObject(ExpectedInt, 'ExpectedInt');
+initMetadataForClass(TooManyDigits, 'TooManyDigits');
+initMetadataForClass(TooFewDigits, 'TooFewDigits');
+initMetadataForClass(WrongConstant, 'WrongConstant');
+initMetadataForClass(Conflicting, 'Conflicting');
+initMetadataForClass(UnsignedIntConsumer, 'UnsignedIntConsumer', VOID, NumberConsumer);
+initMetadataForClass(ParseError, 'ParseError');
+initMetadataForCompanion(Companion_6);
+initMetadataForClass(ParserState, 'ParserState');
+initMetadataForClass(sam$kotlin_Comparator$0, 'sam$kotlin_Comparator$0', VOID, VOID, [Comparator, FunctionAdapter]);
+initMetadataForClass(Parser, 'Parser');
+initMetadataForClass(ParserStructure, 'ParserStructure');
+initMetadataForClass(ParseException, 'ParseException', VOID, Exception);
+initMetadataForClass(NumberSpanParserOperation, 'NumberSpanParserOperation');
+initMetadataForClass(PlainStringParserOperation, 'PlainStringParserOperation');
+initMetadataForClass(UnconditionalModification, 'UnconditionalModification');
+initMetadataForObject(TimeBasedDateTimeUnitSerializer, 'TimeBasedDateTimeUnitSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(DateBasedDateTimeUnitSerializer, 'DateBasedDateTimeUnitSerializer', VOID, AbstractPolymorphicSerializer);
+initMetadataForObject(DayBasedDateTimeUnitSerializer, 'DayBasedDateTimeUnitSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(MonthBasedDateTimeUnitSerializer, 'MonthBasedDateTimeUnitSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(DateTimeUnitSerializer, 'DateTimeUnitSerializer', VOID, AbstractPolymorphicSerializer);
+initMetadataForObject(LocalDateSerializer, 'LocalDateSerializer', VOID, VOID, [KSerializer]);
+initMetadataForObject(YearMonthSerializer, 'YearMonthSerializer', VOID, VOID, [KSerializer]);
+initMetadataForCompanion(Companion_7);
+initMetadataForObject(Formats, 'Formats');
+initMetadataForClass(LocalDate, 'LocalDate', VOID, VOID, [Comparable], VOID, VOID, {0: LocalDateSerializer_getInstance});
+initMetadataForCompanion(Companion_8);
+initMetadataForObject(Formats_0, 'Formats');
+initMetadataForClass(YearMonth, 'YearMonth', VOID, VOID, [Comparable], VOID, VOID, {0: YearMonthSerializer_getInstance});
+//endregion
+function Companion() {
+}
+var Companion_instance;
+function Companion_getInstance() {
+  return Companion_instance;
+}
+function Companion_0() {
+}
+var Companion_instance_0;
+function Companion_getInstance_0() {
+  return Companion_instance_0;
+}
+function Companion_1() {
+}
+var Companion_instance_1;
+function Companion_getInstance_1() {
+  return Companion_instance_1;
+}
+function Companion_2() {
+}
+var Companion_instance_2;
+function Companion_getInstance_2() {
+  return Companion_instance_2;
+}
+function TimeBased(nanoseconds) {
+  DateTimeUnit.call(this);
+  this.s53_1 = nanoseconds;
+  // Inline function 'kotlin.require' call
+  if (!(this.s53_1 > 0n)) {
+    var message = 'Unit duration must be positive, but was ' + this.s53_1.toString() + ' ns.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  if (modulo(this.s53_1, 3600000000000n) === 0n) {
+    this.t53_1 = 'HOUR';
+    this.u53_1 = divide(this.s53_1, 3600000000000n);
+  } else {
+    if (modulo(this.s53_1, 60000000000n) === 0n) {
+      this.t53_1 = 'MINUTE';
+      this.u53_1 = divide(this.s53_1, 60000000000n);
+    } else {
+      var tmp0 = this.s53_1;
+      // Inline function 'kotlin.Long.rem' call
+      var other = 1000000000;
+      if (modulo(tmp0, fromInt(other)) === 0n) {
+        this.t53_1 = 'SECOND';
+        var tmp = this;
+        var tmp0_0 = this.s53_1;
+        // Inline function 'kotlin.Long.div' call
+        var other_0 = 1000000000;
+        tmp.u53_1 = divide(tmp0_0, fromInt(other_0));
+      } else {
+        // Inline function 'kotlin.Long.rem' call
+        var this_0 = this.s53_1;
+        if (modulo(this_0, fromInt(1000000)) === 0n) {
+          this.t53_1 = 'MILLISECOND';
+          var tmp_0 = this;
+          // Inline function 'kotlin.Long.div' call
+          var this_1 = this.s53_1;
+          tmp_0.u53_1 = divide(this_1, fromInt(1000000));
+        } else {
+          // Inline function 'kotlin.Long.rem' call
+          var this_2 = this.s53_1;
+          if (modulo(this_2, fromInt(1000)) === 0n) {
+            this.t53_1 = 'MICROSECOND';
+            var tmp_1 = this;
+            // Inline function 'kotlin.Long.div' call
+            var this_3 = this.s53_1;
+            tmp_1.u53_1 = divide(this_3, fromInt(1000));
+          } else {
+            this.t53_1 = 'NANOSECOND';
+            this.u53_1 = this.s53_1;
+          }
+        }
+      }
+    }
+  }
+}
+protoOf(TimeBased).v53 = function (scalar) {
+  return new TimeBased(safeMultiply(this.s53_1, fromInt(scalar)));
+};
+protoOf(TimeBased).equals = function (other) {
+  var tmp;
+  if (this === other) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    if (other instanceof TimeBased) {
+      tmp_0 = this.s53_1 === other.s53_1;
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(TimeBased).hashCode = function () {
+  return convertToInt(this.s53_1) ^ convertToInt(shiftRight(this.s53_1, 32));
+};
+protoOf(TimeBased).toString = function () {
+  return this.w53(this.u53_1, this.t53_1);
+};
+function DateBased() {
+  DateTimeUnit.call(this);
+}
+function DayBased(days) {
+  DateBased.call(this);
+  this.y53_1 = days;
+  // Inline function 'kotlin.require' call
+  if (!(this.y53_1 > 0)) {
+    var message = 'Unit duration must be positive, but was ' + this.y53_1 + ' days.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+}
+protoOf(DayBased).v53 = function (scalar) {
+  return new DayBased(safeMultiply_0(this.y53_1, scalar));
+};
+protoOf(DayBased).equals = function (other) {
+  var tmp;
+  if (this === other) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    if (other instanceof DayBased) {
+      tmp_0 = this.y53_1 === other.y53_1;
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(DayBased).hashCode = function () {
+  return this.y53_1 ^ 65536;
+};
+protoOf(DayBased).toString = function () {
+  return (this.y53_1 % 7 | 0) === 0 ? this.x53(this.y53_1 / 7 | 0, 'WEEK') : this.x53(this.y53_1, 'DAY');
+};
+function MonthBased(months) {
+  DateBased.call(this);
+  this.z53_1 = months;
+  // Inline function 'kotlin.require' call
+  if (!(this.z53_1 > 0)) {
+    var message = 'Unit duration must be positive, but was ' + this.z53_1 + ' months.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+}
+protoOf(MonthBased).v53 = function (scalar) {
+  return new MonthBased(safeMultiply_0(this.z53_1, scalar));
+};
+protoOf(MonthBased).equals = function (other) {
+  var tmp;
+  if (this === other) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    if (other instanceof MonthBased) {
+      tmp_0 = this.z53_1 === other.z53_1;
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(MonthBased).hashCode = function () {
+  return this.z53_1 ^ 131072;
+};
+protoOf(MonthBased).toString = function () {
+  return (this.z53_1 % 1200 | 0) === 0 ? this.x53(this.z53_1 / 1200 | 0, 'CENTURY') : (this.z53_1 % 12 | 0) === 0 ? this.x53(this.z53_1 / 12 | 0, 'YEAR') : (this.z53_1 % 3 | 0) === 0 ? this.x53(this.z53_1 / 3 | 0, 'QUARTER') : this.x53(this.z53_1, 'MONTH');
+};
+function Companion_3() {
+  Companion_instance_3 = this;
+  this.a54_1 = new TimeBased(1n);
+  this.b54_1 = this.a54_1.v53(1000);
+  this.c54_1 = this.b54_1.v53(1000);
+  this.d54_1 = this.c54_1.v53(1000);
+  this.e54_1 = this.d54_1.v53(60);
+  this.f54_1 = this.e54_1.v53(60);
+  this.g54_1 = new DayBased(1);
+  this.h54_1 = this.g54_1.v53(7);
+  this.i54_1 = new MonthBased(1);
+  this.j54_1 = this.i54_1.v53(3);
+  this.k54_1 = this.i54_1.v53(12);
+  this.l54_1 = this.k54_1.v53(100);
+}
+var Companion_instance_3;
+function Companion_getInstance_3() {
+  if (Companion_instance_3 == null)
+    new Companion_3();
+  return Companion_instance_3;
+}
+function DateTimeUnit() {
+  Companion_getInstance_3();
+}
+protoOf(DateTimeUnit).x53 = function (value, unit) {
+  return value === 1 ? unit : '' + value + '-' + unit;
+};
+protoOf(DateTimeUnit).w53 = function (value, unit) {
+  return value === 1n ? unit : value.toString() + '-' + unit;
+};
+function get_isoDayNumber(_this__u8e3s4) {
+  return _this__u8e3s4.a1_1 + 1 | 0;
+}
+var DayOfWeek_MONDAY_instance;
+var DayOfWeek_TUESDAY_instance;
+var DayOfWeek_WEDNESDAY_instance;
+var DayOfWeek_THURSDAY_instance;
+var DayOfWeek_FRIDAY_instance;
+var DayOfWeek_SATURDAY_instance;
+var DayOfWeek_SUNDAY_instance;
+function values() {
+  return [DayOfWeek_MONDAY_getInstance(), DayOfWeek_TUESDAY_getInstance(), DayOfWeek_WEDNESDAY_getInstance(), DayOfWeek_THURSDAY_getInstance(), DayOfWeek_FRIDAY_getInstance(), DayOfWeek_SATURDAY_getInstance(), DayOfWeek_SUNDAY_getInstance()];
+}
+function get_entries() {
+  if ($ENTRIES == null)
+    $ENTRIES = enumEntries(values());
+  return $ENTRIES;
+}
+var DayOfWeek_entriesInitialized;
+function DayOfWeek_initEntries() {
+  if (DayOfWeek_entriesInitialized)
+    return Unit_instance;
+  DayOfWeek_entriesInitialized = true;
+  DayOfWeek_MONDAY_instance = new DayOfWeek('MONDAY', 0);
+  DayOfWeek_TUESDAY_instance = new DayOfWeek('TUESDAY', 1);
+  DayOfWeek_WEDNESDAY_instance = new DayOfWeek('WEDNESDAY', 2);
+  DayOfWeek_THURSDAY_instance = new DayOfWeek('THURSDAY', 3);
+  DayOfWeek_FRIDAY_instance = new DayOfWeek('FRIDAY', 4);
+  DayOfWeek_SATURDAY_instance = new DayOfWeek('SATURDAY', 5);
+  DayOfWeek_SUNDAY_instance = new DayOfWeek('SUNDAY', 6);
+}
+var $ENTRIES;
+function DayOfWeek(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function DayOfWeek_0(isoDayNumber) {
+  // Inline function 'kotlin.require' call
+  if (!(1 <= isoDayNumber ? isoDayNumber <= 7 : false)) {
+    var message = 'Expected ISO day-of-week number in 1..7, got ' + isoDayNumber;
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  return get_entries().h1(isoDayNumber - 1 | 0);
+}
+function DayOfWeek_MONDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_MONDAY_instance;
+}
+function DayOfWeek_TUESDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_TUESDAY_instance;
+}
+function DayOfWeek_WEDNESDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_WEDNESDAY_instance;
+}
+function DayOfWeek_THURSDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_THURSDAY_instance;
+}
+function DayOfWeek_FRIDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_FRIDAY_instance;
+}
+function DayOfWeek_SATURDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_SATURDAY_instance;
+}
+function DayOfWeek_SUNDAY_getInstance() {
+  DayOfWeek_initEntries();
+  return DayOfWeek_SUNDAY_instance;
+}
+function DateTimeFormatException_init_$Init$($this) {
+  IllegalArgumentException_init_$Init$($this);
+  DateTimeFormatException.call($this);
+  return $this;
+}
+function DateTimeFormatException_init_$Create$() {
+  var tmp = DateTimeFormatException_init_$Init$(objectCreate(protoOf(DateTimeFormatException)));
+  captureStack(tmp, DateTimeFormatException_init_$Create$);
+  return tmp;
+}
+function DateTimeFormatException_init_$Init$_0(message, $this) {
+  IllegalArgumentException_init_$Init$_0(message, $this);
+  DateTimeFormatException.call($this);
+  return $this;
+}
+function DateTimeFormatException_init_$Create$_0(message) {
+  var tmp = DateTimeFormatException_init_$Init$_0(message, objectCreate(protoOf(DateTimeFormatException)));
+  captureStack(tmp, DateTimeFormatException_init_$Create$_0);
+  return tmp;
+}
+function DateTimeFormatException_init_$Init$_1(message, cause, $this) {
+  IllegalArgumentException_init_$Init$_1(message, cause, $this);
+  DateTimeFormatException.call($this);
+  return $this;
+}
+function DateTimeFormatException_init_$Create$_1(message, cause) {
+  var tmp = DateTimeFormatException_init_$Init$_1(message, cause, objectCreate(protoOf(DateTimeFormatException)));
+  captureStack(tmp, DateTimeFormatException_init_$Create$_1);
+  return tmp;
+}
+function DateTimeFormatException() {
+  captureStack(this, DateTimeFormatException);
+}
+function DateTimeArithmeticException_init_$Init$($this) {
+  RuntimeException_init_$Init$($this);
+  DateTimeArithmeticException.call($this);
+  return $this;
+}
+function DateTimeArithmeticException_init_$Create$() {
+  var tmp = DateTimeArithmeticException_init_$Init$(objectCreate(protoOf(DateTimeArithmeticException)));
+  captureStack(tmp, DateTimeArithmeticException_init_$Create$);
+  return tmp;
+}
+function DateTimeArithmeticException_init_$Init$_0(message, cause, $this) {
+  RuntimeException_init_$Init$_0(message, cause, $this);
+  DateTimeArithmeticException.call($this);
+  return $this;
+}
+function DateTimeArithmeticException_init_$Create$_0(message, cause) {
+  var tmp = DateTimeArithmeticException_init_$Init$_0(message, cause, objectCreate(protoOf(DateTimeArithmeticException)));
+  captureStack(tmp, DateTimeArithmeticException_init_$Create$_0);
+  return tmp;
+}
+function DateTimeArithmeticException() {
+  captureStack(this, DateTimeArithmeticException);
+}
+function plus_0(_this__u8e3s4, value, unit) {
+  return plus_1(_this__u8e3s4, fromInt(value), unit);
+}
+function getIsoDateFormat() {
+  return Formats_getInstance().n54();
+}
+function format(_this__u8e3s4, format) {
+  return format.o54(_this__u8e3s4);
+}
+function get_number(_this__u8e3s4) {
+  return _this__u8e3s4.a1_1 + 1 | 0;
+}
+var Month_JANUARY_instance;
+var Month_FEBRUARY_instance;
+var Month_MARCH_instance;
+var Month_APRIL_instance;
+var Month_MAY_instance;
+var Month_JUNE_instance;
+var Month_JULY_instance;
+var Month_AUGUST_instance;
+var Month_SEPTEMBER_instance;
+var Month_OCTOBER_instance;
+var Month_NOVEMBER_instance;
+var Month_DECEMBER_instance;
+function values_0() {
+  return [Month_JANUARY_getInstance(), Month_FEBRUARY_getInstance(), Month_MARCH_getInstance(), Month_APRIL_getInstance(), Month_MAY_getInstance(), Month_JUNE_getInstance(), Month_JULY_getInstance(), Month_AUGUST_getInstance(), Month_SEPTEMBER_getInstance(), Month_OCTOBER_getInstance(), Month_NOVEMBER_getInstance(), Month_DECEMBER_getInstance()];
+}
+function get_entries_0() {
+  if ($ENTRIES_0 == null)
+    $ENTRIES_0 = enumEntries(values_0());
+  return $ENTRIES_0;
+}
+var Month_entriesInitialized;
+function Month_initEntries() {
+  if (Month_entriesInitialized)
+    return Unit_instance;
+  Month_entriesInitialized = true;
+  Month_JANUARY_instance = new Month('JANUARY', 0);
+  Month_FEBRUARY_instance = new Month('FEBRUARY', 1);
+  Month_MARCH_instance = new Month('MARCH', 2);
+  Month_APRIL_instance = new Month('APRIL', 3);
+  Month_MAY_instance = new Month('MAY', 4);
+  Month_JUNE_instance = new Month('JUNE', 5);
+  Month_JULY_instance = new Month('JULY', 6);
+  Month_AUGUST_instance = new Month('AUGUST', 7);
+  Month_SEPTEMBER_instance = new Month('SEPTEMBER', 8);
+  Month_OCTOBER_instance = new Month('OCTOBER', 9);
+  Month_NOVEMBER_instance = new Month('NOVEMBER', 10);
+  Month_DECEMBER_instance = new Month('DECEMBER', 11);
+}
+var $ENTRIES_0;
+function Month(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function Month_0(number) {
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!(1 <= number ? number <= 12 : false)) {
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  return get_entries_0().h1(number - 1 | 0);
+}
+function Month_JANUARY_getInstance() {
+  Month_initEntries();
+  return Month_JANUARY_instance;
+}
+function Month_FEBRUARY_getInstance() {
+  Month_initEntries();
+  return Month_FEBRUARY_instance;
+}
+function Month_MARCH_getInstance() {
+  Month_initEntries();
+  return Month_MARCH_instance;
+}
+function Month_APRIL_getInstance() {
+  Month_initEntries();
+  return Month_APRIL_instance;
+}
+function Month_MAY_getInstance() {
+  Month_initEntries();
+  return Month_MAY_instance;
+}
+function Month_JUNE_getInstance() {
+  Month_initEntries();
+  return Month_JUNE_instance;
+}
+function Month_JULY_getInstance() {
+  Month_initEntries();
+  return Month_JULY_instance;
+}
+function Month_AUGUST_getInstance() {
+  Month_initEntries();
+  return Month_AUGUST_instance;
+}
+function Month_SEPTEMBER_getInstance() {
+  Month_initEntries();
+  return Month_SEPTEMBER_instance;
+}
+function Month_OCTOBER_getInstance() {
+  Month_initEntries();
+  return Month_OCTOBER_instance;
+}
+function Month_NOVEMBER_getInstance() {
+  Month_initEntries();
+  return Month_NOVEMBER_instance;
+}
+function Month_DECEMBER_getInstance() {
+  Month_initEntries();
+  return Month_DECEMBER_instance;
+}
+function AbstractDateTimeFormat() {
+}
+protoOf(AbstractDateTimeFormat).o54 = function (value) {
+  // Inline function 'kotlin.also' call
+  var this_0 = StringBuilder_init_$Create$();
+  this.p54().w54().x54(this.q54(value), this_0);
+  return this_0.toString();
+};
+protoOf(AbstractDateTimeFormat).al = function (input) {
+  var tmp;
+  try {
+    tmp = Parser__match$default_impl_x2xlti(_Parser___init__impl__gdyfby(this.p54().y54()), input, this.s54());
+  } catch ($p) {
+    var tmp_0;
+    if ($p instanceof ParseException) {
+      var e = $p;
+      throw DateTimeFormatException_init_$Create$_1("Failed to parse value from '" + toString(input) + "'", e);
+    } else {
+      throw $p;
+    }
+  }
+  var matched = tmp;
+  try {
+    return this.r54(matched);
+  } catch ($p) {
+    if ($p instanceof IllegalArgumentException) {
+      var e_0 = $p;
+      var message = e_0.message;
+      throw DateTimeFormatException_init_$Create$_1(message == null ? "The value parsed from '" + toString(input) + "' is invalid" : '' + message + " (when parsing '" + toString(input) + "')", e_0);
+    } else {
+      throw $p;
+    }
+  }
+};
+var Padding_NONE_instance;
+var Padding_ZERO_instance;
+var Padding_SPACE_instance;
+var Padding_entriesInitialized;
+function Padding_initEntries() {
+  if (Padding_entriesInitialized)
+    return Unit_instance;
+  Padding_entriesInitialized = true;
+  Padding_NONE_instance = new Padding('NONE', 0);
+  Padding_ZERO_instance = new Padding('ZERO', 1);
+  Padding_SPACE_instance = new Padding('SPACE', 2);
+}
+function Padding(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function Padding_ZERO_getInstance() {
+  Padding_initEntries();
+  return Padding_ZERO_instance;
+}
+function Padding_SPACE_getInstance() {
+  Padding_initEntries();
+  return Padding_SPACE_instance;
+}
+function WithYearMonth() {
+}
+function WithDate() {
+}
+function char(_this__u8e3s4, value) {
+  return _this__u8e3s4.d55(toString_0(value));
+}
+function AbstractDateTimeFormatBuilder() {
+}
+function get_ISO_DATE() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp0 = ISO_DATE$delegate;
+  var tmp = KProperty0;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('ISO_DATE', 0, tmp, _get_ISO_DATE_$ref_powsum(), null);
+  return tmp0.m1();
+}
+var ISO_DATE$delegate;
+function get_ISO_DATE_BASIC() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp0 = ISO_DATE_BASIC$delegate;
+  var tmp = KProperty0;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('ISO_DATE_BASIC', 0, tmp, _get_ISO_DATE_BASIC_$ref_3fs8eb(), null);
+  return tmp0.m1();
+}
+var ISO_DATE_BASIC$delegate;
+function get_emptyIncompleteLocalDate() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  return emptyIncompleteLocalDate;
+}
+var emptyIncompleteLocalDate;
+function IncompleteLocalDate(yearMonth, day, dayOfWeek, dayOfYear) {
+  yearMonth = yearMonth === VOID ? new IncompleteYearMonth() : yearMonth;
+  day = day === VOID ? null : day;
+  dayOfWeek = dayOfWeek === VOID ? null : dayOfWeek;
+  dayOfYear = dayOfYear === VOID ? null : dayOfYear;
+  this.k55_1 = yearMonth;
+  this.l55_1 = day;
+  this.m55_1 = dayOfWeek;
+  this.n55_1 = dayOfYear;
+}
+protoOf(IncompleteLocalDate).o55 = function (_set____db54di) {
+  this.l55_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).p55 = function () {
+  return this.l55_1;
+};
+protoOf(IncompleteLocalDate).q55 = function (_set____db54di) {
+  this.m55_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).r55 = function () {
+  return this.m55_1;
+};
+protoOf(IncompleteLocalDate).s55 = function (_set____db54di) {
+  this.n55_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).t55 = function () {
+  return this.n55_1;
+};
+protoOf(IncompleteLocalDate).u55 = function () {
+  var year = requireParsedField(this.v55(), 'year');
+  var dayOfYear = this.n55_1;
+  var tmp;
+  if (dayOfYear == null) {
+    tmp = new LocalDate(year, requireParsedField(this.a56(), 'monthNumber'), requireParsedField(this.l55_1, 'day'));
+  } else {
+    // Inline function 'kotlin.also' call
+    var this_0 = plus_0(new LocalDate(year, 1, 1), dayOfYear - 1 | 0, Companion_getInstance_3().g54_1);
+    if (!(this_0.w55_1 === year)) {
+      throw DateTimeFormatException_init_$Create$_0('Can not create a LocalDate from the given input: ' + ('the day of year is ' + dayOfYear + ', which is not a valid day of year for the year ' + year));
+    }
+    if (!(this.a56() == null) && !(get_number(this_0.z55()) === this.a56())) {
+      throw DateTimeFormatException_init_$Create$_0('Can not create a LocalDate from the given input: ' + ('the day of year is ' + dayOfYear + ', which is ' + this_0.z55().toString() + ', ') + ('but ' + this.a56() + ' was specified as the month number'));
+    }
+    if (!(this.l55_1 == null) && !(this_0.x55_1 === this.l55_1)) {
+      throw DateTimeFormatException_init_$Create$_0('Can not create a LocalDate from the given input: ' + ('the day of year is ' + dayOfYear + ', which is the day ' + this_0.x55_1 + ' of ' + this_0.z55().toString() + ', ') + ('but ' + this.l55_1 + ' was specified as the day of month'));
+    }
+    tmp = this_0;
+  }
+  var date = tmp;
+  var tmp0_safe_receiver = this.m55_1;
+  if (tmp0_safe_receiver == null)
+    null;
+  else {
+    // Inline function 'kotlin.let' call
+    if (!(tmp0_safe_receiver === get_isoDayNumber(date.r55()))) {
+      throw DateTimeFormatException_init_$Create$_0('Can not create a LocalDate from the given input: ' + ('the day of week is ' + DayOfWeek_0(tmp0_safe_receiver).toString() + ' but the date is ' + date.toString() + ', which is a ' + date.r55().toString()));
+    }
+  }
+  return date;
+};
+protoOf(IncompleteLocalDate).b56 = function (date) {
+  this.c56(date.w55_1);
+  this.d56(get_number(date.z55()));
+  this.l55_1 = date.x55_1;
+  this.m55_1 = get_isoDayNumber(date.r55());
+  this.n55_1 = date.t55();
+};
+protoOf(IncompleteLocalDate).e56 = function () {
+  return new IncompleteLocalDate(this.k55_1.e56(), this.l55_1, this.m55_1, this.n55_1);
+};
+protoOf(IncompleteLocalDate).equals = function (other) {
+  var tmp;
+  var tmp_0;
+  var tmp_1;
+  var tmp_2;
+  if (other instanceof IncompleteLocalDate) {
+    tmp_2 = this.k55_1.equals(other.k55_1);
+  } else {
+    tmp_2 = false;
+  }
+  if (tmp_2) {
+    tmp_1 = this.l55_1 == other.l55_1;
+  } else {
+    tmp_1 = false;
+  }
+  if (tmp_1) {
+    tmp_0 = this.m55_1 == other.m55_1;
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = this.n55_1 == other.n55_1;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(IncompleteLocalDate).hashCode = function () {
+  var tmp = imul(this.k55_1.hashCode(), 29791);
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver = this.l55_1;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+  var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+  var tmp_0 = tmp + imul(tmp$ret$0, 961) | 0;
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver_0 = this.m55_1;
+  var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+  var tmp$ret$1 = tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0;
+  var tmp_1 = tmp_0 + imul(tmp$ret$1, 31) | 0;
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver_1 = this.n55_1;
+  var tmp1_elvis_lhs_1 = tmp0_safe_receiver_1 == null ? null : hashCode(tmp0_safe_receiver_1);
+  return tmp_1 + (tmp1_elvis_lhs_1 == null ? 0 : tmp1_elvis_lhs_1) | 0;
+};
+protoOf(IncompleteLocalDate).toString = function () {
+  var tmp;
+  if (this.n55_1 == null) {
+    var tmp_0 = this.k55_1.toString();
+    var tmp0_elvis_lhs = this.l55_1;
+    var tmp_1 = toString(tmp0_elvis_lhs == null ? '??' : tmp0_elvis_lhs);
+    var tmp1_elvis_lhs = this.m55_1;
+    tmp = tmp_0 + '-' + tmp_1 + ' (day of week is ' + toString(tmp1_elvis_lhs == null ? '??' : tmp1_elvis_lhs) + ')';
+  } else if (this.l55_1 == null && this.a56() == null) {
+    var tmp2_elvis_lhs = this.k55_1.f56_1;
+    var tmp_2 = toString(tmp2_elvis_lhs == null ? '??' : tmp2_elvis_lhs);
+    var tmp_3 = this.n55_1;
+    var tmp3_elvis_lhs = this.m55_1;
+    tmp = '(' + tmp_2 + ')-' + tmp_3 + ' (day of week is ' + toString(tmp3_elvis_lhs == null ? '??' : tmp3_elvis_lhs) + ')';
+  } else {
+    var tmp_4 = this.k55_1.toString();
+    var tmp4_elvis_lhs = this.l55_1;
+    var tmp_5 = toString(tmp4_elvis_lhs == null ? '??' : tmp4_elvis_lhs);
+    var tmp5_elvis_lhs = this.m55_1;
+    tmp = tmp_4 + '-' + tmp_5 + ' (day of week is ' + toString(tmp5_elvis_lhs == null ? '??' : tmp5_elvis_lhs) + ', day of year is ' + this.n55_1 + ')';
+  }
+  return tmp;
+};
+protoOf(IncompleteLocalDate).c56 = function (_set____db54di) {
+  this.k55_1.f56_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).v55 = function () {
+  return this.k55_1.f56_1;
+};
+protoOf(IncompleteLocalDate).d56 = function (_set____db54di) {
+  this.k55_1.g56_1 = _set____db54di;
+};
+protoOf(IncompleteLocalDate).a56 = function () {
+  return this.k55_1.g56_1;
+};
+function Companion_4() {
+}
+protoOf(Companion_4).h56 = function (block) {
+  var builder = new Builder(new AppendableFormatStructure());
+  block(builder);
+  return new LocalDateFormat(builder.i2l());
+};
+var Companion_instance_4;
+function Companion_getInstance_4() {
+  return Companion_instance_4;
+}
+function Builder(actualBuilder) {
+  this.i56_1 = actualBuilder;
+}
+protoOf(Builder).g55 = function () {
+  return this.i56_1;
+};
+protoOf(Builder).j56 = function (structure) {
+  return this.i56_1.i55(structure);
+};
+function LocalDateFormat(actualFormat) {
+  AbstractDateTimeFormat.call(this);
+  this.l56_1 = actualFormat;
+}
+protoOf(LocalDateFormat).p54 = function () {
+  return this.l56_1;
+};
+protoOf(LocalDateFormat).m56 = function (value) {
+  // Inline function 'kotlin.apply' call
+  var this_0 = new IncompleteLocalDate();
+  this_0.b56(value);
+  return this_0;
+};
+protoOf(LocalDateFormat).q54 = function (value) {
+  return this.m56(value instanceof LocalDate ? value : THROW_CCE());
+};
+protoOf(LocalDateFormat).n56 = function (intermediate) {
+  return intermediate.u55();
+};
+protoOf(LocalDateFormat).r54 = function (intermediate) {
+  return this.n56(intermediate instanceof IncompleteLocalDate ? intermediate : THROW_CCE());
+};
+protoOf(LocalDateFormat).s54 = function () {
+  return get_emptyIncompleteLocalDate();
+};
+function AbstractWithDateBuilder() {
+}
+function DayDirective(padding) {
+  var tmp = DateFields_getInstance().o56_1;
+  // Inline function 'kotlinx.datetime.format.minDigits' call
+  var tmp_0 = padding.equals(Padding_ZERO_getInstance()) ? 2 : 1;
+  // Inline function 'kotlinx.datetime.format.spaces' call
+  var tmp$ret$1 = padding.equals(Padding_SPACE_getInstance()) ? 2 : null;
+  UnsignedIntFieldFormatDirective.call(this, tmp, tmp_0, tmp$ret$1);
+  this.v56_1 = padding;
+}
+protoOf(DayDirective).equals = function (other) {
+  var tmp;
+  if (other instanceof DayDirective) {
+    tmp = this.v56_1.equals(other.v56_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(DayDirective).hashCode = function () {
+  return this.v56_1.hashCode();
+};
+function DateFieldContainer$_get_day_$ref_2ebhxx() {
+  return function (p0) {
+    return p0.p55();
+  };
+}
+function DateFieldContainer$_set_day_$ref_s0jsax() {
+  return function (p0, p1) {
+    p0.o55(p1);
+    return Unit_instance;
+  };
+}
+function DateFieldContainer$_get_dayOfWeek_$ref_thwqom() {
+  return function (p0) {
+    return p0.r55();
+  };
+}
+function DateFieldContainer$_set_dayOfWeek_$ref_ea586a() {
+  return function (p0, p1) {
+    p0.q55(p1);
+    return Unit_instance;
+  };
+}
+function DateFieldContainer$_get_dayOfYear_$ref_2m6gfz() {
+  return function (p0) {
+    return p0.t55();
+  };
+}
+function DateFieldContainer$_set_dayOfYear_$ref_cll22d() {
+  return function (p0, p1) {
+    p0.s55(p1);
+    return Unit_instance;
+  };
+}
+function DateFields() {
+  DateFields_instance = this;
+  var tmp = this;
+  var tmp_0 = KMutableProperty1;
+  var tmp_1 = DateFieldContainer$_get_day_$ref_2ebhxx();
+  tmp.o56_1 = new UnsignedFieldSpec(new PropertyAccessor(getPropertyCallableRef('day', 1, tmp_0, tmp_1, DateFieldContainer$_set_day_$ref_s0jsax())), 1, 31);
+  var tmp_2 = this;
+  var tmp_3 = KMutableProperty1;
+  var tmp_4 = DateFieldContainer$_get_dayOfWeek_$ref_thwqom();
+  tmp_2.p56_1 = new UnsignedFieldSpec(new PropertyAccessor(getPropertyCallableRef('dayOfWeek', 1, tmp_3, tmp_4, DateFieldContainer$_set_dayOfWeek_$ref_ea586a())), 1, 7);
+  var tmp_5 = this;
+  var tmp_6 = KMutableProperty1;
+  var tmp_7 = DateFieldContainer$_get_dayOfYear_$ref_2m6gfz();
+  tmp_5.q56_1 = new UnsignedFieldSpec(new PropertyAccessor(getPropertyCallableRef('dayOfYear', 1, tmp_6, tmp_7, DateFieldContainer$_set_dayOfYear_$ref_cll22d())), 1, 366);
+}
+var DateFields_instance;
+function DateFields_getInstance() {
+  if (DateFields_instance == null)
+    new DateFields();
+  return DateFields_instance;
+}
+function ISO_DATE$delegate$lambda() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp = Companion_instance_4;
+  return tmp.h56(ISO_DATE$delegate$lambda$lambda);
+}
+function ISO_DATE$delegate$lambda$lambda($this$build) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  $this$build.a55();
+  char($this$build, _Char___init__impl__6a9atx(45));
+  $this$build.c55();
+  char($this$build, _Char___init__impl__6a9atx(45));
+  $this$build.f55();
+  return Unit_instance;
+}
+function _get_ISO_DATE_$ref_powsum() {
+  return function () {
+    return get_ISO_DATE();
+  };
+}
+function ISO_DATE_BASIC$delegate$lambda() {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  var tmp = Companion_instance_4;
+  return tmp.h56(ISO_DATE_BASIC$delegate$lambda$lambda);
+}
+function ISO_DATE_BASIC$delegate$lambda$lambda($this$build) {
+  _init_properties_LocalDateFormat_kt__k1uk9u();
+  $this$build.a55();
+  $this$build.c55();
+  $this$build.f55();
+  return Unit_instance;
+}
+function _get_ISO_DATE_BASIC_$ref_3fs8eb() {
+  return function () {
+    return get_ISO_DATE_BASIC();
+  };
+}
+var properties_initialized_LocalDateFormat_kt_fmnlhc;
+function _init_properties_LocalDateFormat_kt__k1uk9u() {
+  if (!properties_initialized_LocalDateFormat_kt_fmnlhc) {
+    properties_initialized_LocalDateFormat_kt_fmnlhc = true;
+    ISO_DATE$delegate = lazy(ISO_DATE$delegate$lambda);
+    ISO_DATE_BASIC$delegate = lazy(ISO_DATE_BASIC$delegate$lambda);
+    emptyIncompleteLocalDate = new IncompleteLocalDate();
+  }
+}
+function get_emptyIncompleteYearMonth() {
+  _init_properties_YearMonthFormat_kt__i0mmu0();
+  return emptyIncompleteYearMonth;
+}
+var emptyIncompleteYearMonth;
+function get_ISO_YEAR_MONTH() {
+  _init_properties_YearMonthFormat_kt__i0mmu0();
+  var tmp0 = ISO_YEAR_MONTH$delegate;
+  var tmp = KProperty0;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('ISO_YEAR_MONTH', 0, tmp, _get_ISO_YEAR_MONTH_$ref_y3tv9a(), null);
+  return tmp0.m1();
+}
+var ISO_YEAR_MONTH$delegate;
+function IncompleteYearMonth(year, monthNumber) {
+  year = year === VOID ? null : year;
+  monthNumber = monthNumber === VOID ? null : monthNumber;
+  this.f56_1 = year;
+  this.g56_1 = monthNumber;
+}
+protoOf(IncompleteYearMonth).c56 = function (_set____db54di) {
+  this.f56_1 = _set____db54di;
+};
+protoOf(IncompleteYearMonth).v55 = function () {
+  return this.f56_1;
+};
+protoOf(IncompleteYearMonth).d56 = function (_set____db54di) {
+  this.g56_1 = _set____db54di;
+};
+protoOf(IncompleteYearMonth).a56 = function () {
+  return this.g56_1;
+};
+protoOf(IncompleteYearMonth).a57 = function () {
+  var year = requireParsedField(this.f56_1, 'year');
+  var month = requireParsedField(this.g56_1, 'monthNumber');
+  return new YearMonth(year, month);
+};
+protoOf(IncompleteYearMonth).b57 = function (yearMonth) {
+  this.f56_1 = yearMonth.c57_1;
+  this.g56_1 = get_number(yearMonth.z55());
+};
+protoOf(IncompleteYearMonth).e56 = function () {
+  return new IncompleteYearMonth(this.f56_1, this.g56_1);
+};
+protoOf(IncompleteYearMonth).equals = function (other) {
+  var tmp;
+  var tmp_0;
+  if (other instanceof IncompleteYearMonth) {
+    tmp_0 = this.f56_1 == other.f56_1;
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = this.g56_1 == other.g56_1;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(IncompleteYearMonth).hashCode = function () {
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver = this.f56_1;
+  var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : hashCode(tmp0_safe_receiver);
+  var tmp$ret$0 = tmp1_elvis_lhs == null ? 0 : tmp1_elvis_lhs;
+  var tmp = imul(tmp$ret$0, 31);
+  // Inline function 'kotlin.hashCode' call
+  var tmp0_safe_receiver_0 = this.g56_1;
+  var tmp1_elvis_lhs_0 = tmp0_safe_receiver_0 == null ? null : hashCode(tmp0_safe_receiver_0);
+  return tmp + (tmp1_elvis_lhs_0 == null ? 0 : tmp1_elvis_lhs_0) | 0;
+};
+protoOf(IncompleteYearMonth).toString = function () {
+  var tmp0_elvis_lhs = this.f56_1;
+  var tmp = toString(tmp0_elvis_lhs == null ? '??' : tmp0_elvis_lhs);
+  var tmp1_elvis_lhs = this.g56_1;
+  return tmp + '-' + toString(tmp1_elvis_lhs == null ? '??' : tmp1_elvis_lhs);
+};
+function requireParsedField(field, name) {
+  _init_properties_YearMonthFormat_kt__i0mmu0();
+  if (field == null) {
+    throw DateTimeFormatException_init_$Create$_0('Can not create a ' + name + ' from the given input: the field ' + name + ' is missing');
+  }
+  return field;
+}
+function AbstractWithYearMonthBuilder() {
+}
+function Companion_5() {
+}
+protoOf(Companion_5).e57 = function (block) {
+  var builder = new Builder_0(new AppendableFormatStructure());
+  block(builder);
+  return new YearMonthFormat(builder.i2l());
+};
+var Companion_instance_5;
+function Companion_getInstance_5() {
+  return Companion_instance_5;
+}
+function Builder_0(actualBuilder) {
+  this.f57_1 = actualBuilder;
+}
+protoOf(Builder_0).g55 = function () {
+  return this.f57_1;
+};
+protoOf(Builder_0).k56 = function (structure) {
+  return this.f57_1.i55(structure);
+};
+function YearMonthFormat(actualFormat) {
+  AbstractDateTimeFormat.call(this);
+  this.g57_1 = actualFormat;
+}
+protoOf(YearMonthFormat).p54 = function () {
+  return this.g57_1;
+};
+protoOf(YearMonthFormat).h57 = function (value) {
+  // Inline function 'kotlin.apply' call
+  var this_0 = new IncompleteYearMonth();
+  this_0.b57(value);
+  return this_0;
+};
+protoOf(YearMonthFormat).q54 = function (value) {
+  return this.h57(value instanceof YearMonth ? value : THROW_CCE());
+};
+protoOf(YearMonthFormat).i57 = function (intermediate) {
+  return intermediate.a57();
+};
+protoOf(YearMonthFormat).r54 = function (intermediate) {
+  return this.i57(intermediate instanceof IncompleteYearMonth ? intermediate : THROW_CCE());
+};
+protoOf(YearMonthFormat).s54 = function () {
+  return get_emptyIncompleteYearMonth();
+};
+function YearDirective(padding, isYearOfEra) {
+  isYearOfEra = isYearOfEra === VOID ? false : isYearOfEra;
+  var tmp = YearMonthFields_getInstance().j57_1;
+  // Inline function 'kotlinx.datetime.format.minDigits' call
+  var tmp_0 = padding.equals(Padding_ZERO_getInstance()) ? 4 : 1;
+  // Inline function 'kotlinx.datetime.format.spaces' call
+  var tmp$ret$1 = padding.equals(Padding_SPACE_getInstance()) ? 4 : null;
+  SignedIntFieldFormatDirective.call(this, tmp, tmp_0, null, tmp$ret$1, 4);
+  this.q57_1 = padding;
+  this.r57_1 = isYearOfEra;
+}
+protoOf(YearDirective).equals = function (other) {
+  var tmp;
+  var tmp_0;
+  if (other instanceof YearDirective) {
+    tmp_0 = this.q57_1.equals(other.q57_1);
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = this.r57_1 === other.r57_1;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(YearDirective).hashCode = function () {
+  return imul(this.q57_1.hashCode(), 31) + getBooleanHashCode(this.r57_1) | 0;
+};
+function MonthDirective(padding) {
+  var tmp = YearMonthFields_getInstance().k57_1;
+  // Inline function 'kotlinx.datetime.format.minDigits' call
+  var tmp_0 = padding.equals(Padding_ZERO_getInstance()) ? 2 : 1;
+  // Inline function 'kotlinx.datetime.format.spaces' call
+  var tmp$ret$1 = padding.equals(Padding_SPACE_getInstance()) ? 2 : null;
+  UnsignedIntFieldFormatDirective.call(this, tmp, tmp_0, tmp$ret$1);
+  this.b58_1 = padding;
+}
+protoOf(MonthDirective).equals = function (other) {
+  var tmp;
+  if (other instanceof MonthDirective) {
+    tmp = this.b58_1.equals(other.b58_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(MonthDirective).hashCode = function () {
+  return this.b58_1.hashCode();
+};
+function YearMonthFieldContainer$_get_year_$ref_7j3zdj() {
+  return function (p0) {
+    return p0.v55();
+  };
+}
+function YearMonthFieldContainer$_set_year_$ref_kc0aub() {
+  return function (p0, p1) {
+    p0.c56(p1);
+    return Unit_instance;
+  };
+}
+function YearMonthFieldContainer$_get_monthNumber_$ref_pn0wu5() {
+  return function (p0) {
+    return p0.a56();
+  };
+}
+function YearMonthFieldContainer$_set_monthNumber_$ref_fjapbl() {
+  return function (p0, p1) {
+    p0.d56(p1);
+    return Unit_instance;
+  };
+}
+function YearMonthFields() {
+  YearMonthFields_instance = this;
+  var tmp = this;
+  var tmp_0 = KMutableProperty1;
+  var tmp_1 = YearMonthFieldContainer$_get_year_$ref_7j3zdj();
+  tmp.j57_1 = new GenericFieldSpec(new PropertyAccessor(getPropertyCallableRef('year', 1, tmp_0, tmp_1, YearMonthFieldContainer$_set_year_$ref_kc0aub())));
+  var tmp_2 = this;
+  var tmp_3 = KMutableProperty1;
+  var tmp_4 = YearMonthFieldContainer$_get_monthNumber_$ref_pn0wu5();
+  tmp_2.k57_1 = new UnsignedFieldSpec(new PropertyAccessor(getPropertyCallableRef('monthNumber', 1, tmp_3, tmp_4, YearMonthFieldContainer$_set_monthNumber_$ref_fjapbl())), 1, 12);
+}
+var YearMonthFields_instance;
+function YearMonthFields_getInstance() {
+  if (YearMonthFields_instance == null)
+    new YearMonthFields();
+  return YearMonthFields_instance;
+}
+function ISO_YEAR_MONTH$delegate$lambda() {
+  _init_properties_YearMonthFormat_kt__i0mmu0();
+  var tmp = Companion_instance_5;
+  return tmp.e57(ISO_YEAR_MONTH$delegate$lambda$lambda);
+}
+function ISO_YEAR_MONTH$delegate$lambda$lambda($this$build) {
+  _init_properties_YearMonthFormat_kt__i0mmu0();
+  $this$build.a55();
+  char($this$build, _Char___init__impl__6a9atx(45));
+  $this$build.c55();
+  return Unit_instance;
+}
+function _get_ISO_YEAR_MONTH_$ref_y3tv9a() {
+  return function () {
+    return get_ISO_YEAR_MONTH();
+  };
+}
+var properties_initialized_YearMonthFormat_kt_fp0mk6;
+function _init_properties_YearMonthFormat_kt__i0mmu0() {
+  if (!properties_initialized_YearMonthFormat_kt_fp0mk6) {
+    properties_initialized_YearMonthFormat_kt_fp0mk6 = true;
+    emptyIncompleteYearMonth = new IncompleteYearMonth();
+    ISO_YEAR_MONTH$delegate = lazy(ISO_YEAR_MONTH$delegate$lambda);
+  }
+}
+function monthLength(_this__u8e3s4, isLeapYear) {
+  switch (_this__u8e3s4) {
+    case 2:
+      return isLeapYear ? 29 : 28;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+    default:
+      return 31;
+  }
+}
+function isLeapYear(year) {
+  var prolepticYear = fromInt(year);
+  var tmp;
+  if ((prolepticYear & 3n) === 0n) {
+    var tmp_0;
+    // Inline function 'kotlin.Long.rem' call
+    if (!(modulo(prolepticYear, fromInt(100)) === 0n)) {
+      tmp_0 = true;
+    } else {
+      // Inline function 'kotlin.Long.rem' call
+      tmp_0 = modulo(prolepticYear, fromInt(400)) === 0n;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+}
+function AppendableFormatStructure() {
+  var tmp = this;
+  // Inline function 'kotlin.collections.mutableListOf' call
+  tmp.h55_1 = ArrayList_init_$Create$();
+}
+protoOf(AppendableFormatStructure).i2l = function () {
+  return new ConcatenatedFormatStructure(this.h55_1);
+};
+protoOf(AppendableFormatStructure).i55 = function (format) {
+  if (isInterface(format, NonConcatenatedFormatStructure))
+    this.h55_1.e1(format);
+  else {
+    if (format instanceof ConcatenatedFormatStructure) {
+      // Inline function 'kotlin.collections.forEach' call
+      var _iterator__ex2g4s = format.j55_1.t();
+      while (_iterator__ex2g4s.u()) {
+        var element = _iterator__ex2g4s.v();
+        this.h55_1.e1(element);
+      }
+    } else {
+      noWhenBranchMatchedException();
+    }
+  }
+};
+function Accessor$getterNotNull$ref(p0) {
+  var l = function (_this__u8e3s4) {
+    return p0.c58(_this__u8e3s4);
+  };
+  l.callableName = 'getterNotNull';
+  return l;
+}
+function UnsignedIntFieldFormatDirective(field, minDigits, spacePadding) {
+  this.w56_1 = field;
+  this.x56_1 = minDigits;
+  this.y56_1 = spacePadding;
+  this.z56_1 = this.w56_1.j58_1;
+  // Inline function 'kotlin.require' call
+  if (!(this.x56_1 >= 0)) {
+    var message = 'The minimum number of digits (' + this.x56_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(this.z56_1 >= this.x56_1)) {
+    var message_0 = 'The maximum number of digits (' + this.z56_1 + ') is less than the minimum number of digits (' + this.x56_1 + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  if (!(this.y56_1 == null)) {
+    // Inline function 'kotlin.require' call
+    if (!(this.y56_1 > this.x56_1)) {
+      var message_1 = 'The space padding (' + this.y56_1 + ') should be more than the minimum number of digits (' + this.x56_1 + ')';
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+  }
+}
+protoOf(UnsignedIntFieldFormatDirective).w54 = function () {
+  var formatter = new UnsignedIntFormatterStructure(Accessor$getterNotNull$ref(this.w56_1.d58_1), this.x56_1);
+  return !(this.y56_1 == null) ? new SpacePaddedFormatter(formatter, this.y56_1) : formatter;
+};
+protoOf(UnsignedIntFieldFormatDirective).y54 = function () {
+  return spaceAndZeroPaddedUnsignedInt(this.x56_1, this.z56_1, this.y56_1, this.w56_1.d58_1, this.w56_1.g58_1);
+};
+function Accessor$getterNotNull$ref_0(p0) {
+  var l = function (_this__u8e3s4) {
+    return p0.c58(_this__u8e3s4);
+  };
+  l.callableName = 'getterNotNull';
+  return l;
+}
+function SignedIntFieldFormatDirective(field, minDigits, maxDigits, spacePadding, outputPlusOnExceededWidth) {
+  this.s57_1 = field;
+  this.t57_1 = minDigits;
+  this.u57_1 = maxDigits;
+  this.v57_1 = spacePadding;
+  this.w57_1 = outputPlusOnExceededWidth;
+  // Inline function 'kotlin.require' call
+  if (!(this.t57_1 == null || this.t57_1 >= 0)) {
+    var message = 'The minimum number of digits (' + this.t57_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(this.u57_1 == null || this.t57_1 == null || this.u57_1 >= this.t57_1)) {
+    var message_0 = 'The maximum number of digits (' + this.u57_1 + ') is less than the minimum number of digits (' + this.t57_1 + ')';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+protoOf(SignedIntFieldFormatDirective).w54 = function () {
+  var tmp = Accessor$getterNotNull$ref_0(this.s57_1.k58());
+  var tmp0_elvis_lhs = this.t57_1;
+  var formatter = new SignedIntFormatterStructure(tmp, tmp0_elvis_lhs == null ? 0 : tmp0_elvis_lhs, this.w57_1);
+  return !(this.v57_1 == null) ? new SpacePaddedFormatter(formatter, this.v57_1) : formatter;
+};
+protoOf(SignedIntFieldFormatDirective).y54 = function () {
+  return SignedIntParser(this.t57_1, this.u57_1, this.v57_1, this.s57_1.k58(), this.s57_1.m(), this.w57_1);
+};
+function GenericFieldSpec(accessor, name, defaultValue, sign) {
+  name = name === VOID ? accessor.m() : name;
+  defaultValue = defaultValue === VOID ? null : defaultValue;
+  sign = sign === VOID ? null : sign;
+  AbstractFieldSpec.call(this);
+  this.l58_1 = accessor;
+  this.m58_1 = name;
+  this.n58_1 = defaultValue;
+  this.o58_1 = sign;
+}
+protoOf(GenericFieldSpec).k58 = function () {
+  return this.l58_1;
+};
+protoOf(GenericFieldSpec).m = function () {
+  return this.m58_1;
+};
+protoOf(GenericFieldSpec).p58 = function () {
+  return this.n58_1;
+};
+function PropertyAccessor(property, name) {
+  name = name === VOID ? property.callableName : name;
+  this.q58_1 = property;
+  this.r58_1 = name;
+}
+protoOf(PropertyAccessor).m = function () {
+  return this.r58_1;
+};
+protoOf(PropertyAccessor).s58 = function (container, newValue) {
+  var oldValue = this.q58_1.get(container);
+  var tmp;
+  if (oldValue === null) {
+    this.q58_1.set(container, newValue);
+    tmp = null;
+  } else if (equals(oldValue, newValue)) {
+    tmp = null;
+  } else {
+    tmp = oldValue;
+  }
+  return tmp;
+};
+protoOf(PropertyAccessor).t58 = function (container, newValue) {
+  var tmp = (container == null ? true : !(container == null)) ? container : THROW_CCE();
+  return this.s58(tmp, (newValue == null ? true : !(newValue == null)) ? newValue : THROW_CCE());
+};
+protoOf(PropertyAccessor).u58 = function (container) {
+  return this.q58_1.get(container);
+};
+function UnsignedFieldSpec(accessor, minValue, maxValue, name, defaultValue, sign) {
+  name = name === VOID ? accessor.m() : name;
+  defaultValue = defaultValue === VOID ? null : defaultValue;
+  sign = sign === VOID ? null : sign;
+  AbstractFieldSpec.call(this);
+  this.d58_1 = accessor;
+  this.e58_1 = minValue;
+  this.f58_1 = maxValue;
+  this.g58_1 = name;
+  this.h58_1 = defaultValue;
+  this.i58_1 = sign;
+  var tmp = this;
+  var tmp_0;
+  if (this.f58_1 < 10) {
+    tmp_0 = 1;
+  } else if (this.f58_1 < 100) {
+    tmp_0 = 2;
+  } else if (this.f58_1 < 1000) {
+    tmp_0 = 3;
+  } else {
+    throw IllegalArgumentException_init_$Create$('Max value ' + this.f58_1 + ' is too large');
+  }
+  tmp.j58_1 = tmp_0;
+}
+protoOf(UnsignedFieldSpec).k58 = function () {
+  return this.d58_1;
+};
+protoOf(UnsignedFieldSpec).m = function () {
+  return this.g58_1;
+};
+protoOf(UnsignedFieldSpec).p58 = function () {
+  return this.h58_1;
+};
+function Accessor() {
+}
+function AbstractFieldSpec() {
+}
+protoOf(AbstractFieldSpec).toString = function () {
+  return 'The field ' + this.m() + ' (default value is ' + toString_1(this.p58()) + ')';
+};
+function CachedFormatStructure(formats) {
+  ConcatenatedFormatStructure.call(this, formats);
+  this.u54_1 = protoOf(ConcatenatedFormatStructure).w54.call(this);
+  this.v54_1 = protoOf(ConcatenatedFormatStructure).y54.call(this);
+}
+protoOf(CachedFormatStructure).w54 = function () {
+  return this.u54_1;
+};
+protoOf(CachedFormatStructure).y54 = function () {
+  return this.v54_1;
+};
+function BasicFormatStructure(directive) {
+  this.v58_1 = directive;
+}
+protoOf(BasicFormatStructure).toString = function () {
+  return 'BasicFormatStructure(' + toString(this.v58_1) + ')';
+};
+protoOf(BasicFormatStructure).equals = function (other) {
+  var tmp;
+  if (other instanceof BasicFormatStructure) {
+    tmp = equals(this.v58_1, other.v58_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(BasicFormatStructure).hashCode = function () {
+  return hashCode(this.v58_1);
+};
+protoOf(BasicFormatStructure).y54 = function () {
+  return this.v58_1.y54();
+};
+protoOf(BasicFormatStructure).w54 = function () {
+  return this.v58_1.w54();
+};
+function ConstantFormatStructure(string) {
+  this.w58_1 = string;
+}
+protoOf(ConstantFormatStructure).toString = function () {
+  return 'ConstantFormatStructure(' + this.w58_1 + ')';
+};
+protoOf(ConstantFormatStructure).equals = function (other) {
+  var tmp;
+  if (other instanceof ConstantFormatStructure) {
+    tmp = this.w58_1 === other.w58_1;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(ConstantFormatStructure).hashCode = function () {
+  return getStringHashCode(this.w58_1);
+};
+protoOf(ConstantFormatStructure).y54 = function () {
+  var tmp;
+  // Inline function 'kotlin.text.isEmpty' call
+  var this_0 = this.w58_1;
+  if (charSequenceLength(this_0) === 0) {
+    tmp = emptyList();
+  } else {
+    // Inline function 'kotlin.collections.buildList' call
+    // Inline function 'kotlin.collections.buildListInternal' call
+    // Inline function 'kotlin.apply' call
+    var this_1 = ArrayList_init_$Create$();
+    var tmp_0;
+    if (isAsciiDigit(charCodeAt(this.w58_1, 0))) {
+      var tmp0 = this.w58_1;
+      var tmp$ret$2;
+      $l$block: {
+        // Inline function 'kotlin.text.takeWhile' call
+        var inductionVariable = 0;
+        var last = tmp0.length;
+        if (inductionVariable < last)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var it = charCodeAt(tmp0, index);
+            if (!isAsciiDigit(it)) {
+              tmp$ret$2 = substring(tmp0, 0, index);
+              break $l$block;
+            }
+          }
+           while (inductionVariable < last);
+        tmp$ret$2 = tmp0;
+      }
+      this_1.e1(new NumberSpanParserOperation(listOf(new ConstantNumberConsumer(tmp$ret$2))));
+      var tmp0_0 = this.w58_1;
+      var tmp$ret$4;
+      $l$block_0: {
+        // Inline function 'kotlin.text.dropWhile' call
+        var inductionVariable_0 = 0;
+        var last_0 = charSequenceLength(tmp0_0) - 1 | 0;
+        if (inductionVariable_0 <= last_0)
+          do {
+            var index_0 = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + 1 | 0;
+            var it_0 = charCodeAt(tmp0_0, index_0);
+            if (!isAsciiDigit(it_0)) {
+              tmp$ret$4 = substring_0(tmp0_0, index_0);
+              break $l$block_0;
+            }
+          }
+           while (inductionVariable_0 <= last_0);
+        tmp$ret$4 = '';
+      }
+      tmp_0 = tmp$ret$4;
+    } else {
+      tmp_0 = this.w58_1;
+    }
+    var suffix = tmp_0;
+    // Inline function 'kotlin.text.isNotEmpty' call
+    if (charSequenceLength(suffix) > 0) {
+      if (isAsciiDigit(charCodeAt(suffix, suffix.length - 1 | 0))) {
+        var tmp$ret$7;
+        $l$block_1: {
+          // Inline function 'kotlin.text.dropLastWhile' call
+          var inductionVariable_1 = get_lastIndex(suffix);
+          if (0 <= inductionVariable_1)
+            do {
+              var index_1 = inductionVariable_1;
+              inductionVariable_1 = inductionVariable_1 + -1 | 0;
+              var it_1 = charCodeAt(suffix, index_1);
+              if (!isAsciiDigit(it_1)) {
+                tmp$ret$7 = substring(suffix, 0, index_1 + 1 | 0);
+                break $l$block_1;
+              }
+            }
+             while (0 <= inductionVariable_1);
+          tmp$ret$7 = '';
+        }
+        this_1.e1(new PlainStringParserOperation(tmp$ret$7));
+        var tmp$ret$9;
+        $l$block_2: {
+          // Inline function 'kotlin.text.takeLastWhile' call
+          var inductionVariable_2 = get_lastIndex(suffix);
+          if (0 <= inductionVariable_2)
+            do {
+              var index_2 = inductionVariable_2;
+              inductionVariable_2 = inductionVariable_2 + -1 | 0;
+              var it_2 = charCodeAt(suffix, index_2);
+              if (!isAsciiDigit(it_2)) {
+                tmp$ret$9 = substring_0(suffix, index_2 + 1 | 0);
+                break $l$block_2;
+              }
+            }
+             while (0 <= inductionVariable_2);
+          tmp$ret$9 = suffix;
+        }
+        this_1.e1(new NumberSpanParserOperation(listOf(new ConstantNumberConsumer(tmp$ret$9))));
+      } else {
+        this_1.e1(new PlainStringParserOperation(suffix));
+      }
+    }
+    tmp = this_1.j3();
+  }
+  return new ParserStructure(tmp, emptyList());
+};
+protoOf(ConstantFormatStructure).w54 = function () {
+  return new ConstantStringFormatterStructure(this.w58_1);
+};
+function ConcatenatedFormatStructure(formats) {
+  this.j55_1 = formats;
+}
+protoOf(ConcatenatedFormatStructure).toString = function () {
+  return 'ConcatenatedFormatStructure(' + joinToString(this.j55_1, ', ') + ')';
+};
+protoOf(ConcatenatedFormatStructure).equals = function (other) {
+  var tmp;
+  if (other instanceof ConcatenatedFormatStructure) {
+    tmp = equals(this.j55_1, other.j55_1);
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(ConcatenatedFormatStructure).hashCode = function () {
+  return hashCode(this.j55_1);
+};
+protoOf(ConcatenatedFormatStructure).y54 = function () {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = this.j55_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.t();
+  while (_iterator__ex2g4s.u()) {
+    var item = _iterator__ex2g4s.v();
+    var tmp$ret$0 = item.y54();
+    destination.e1(tmp$ret$0);
+  }
+  return concat(destination);
+};
+protoOf(ConcatenatedFormatStructure).w54 = function () {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = this.j55_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.t();
+  while (_iterator__ex2g4s.u()) {
+    var item = _iterator__ex2g4s.v();
+    var tmp$ret$0 = item.w54();
+    destination.e1(tmp$ret$0);
+  }
+  var formatters = destination;
+  var tmp;
+  if (formatters.g1() === 1) {
+    tmp = single(formatters);
+  } else {
+    tmp = new ConcatenatedFormatter(formatters);
+  }
+  return tmp;
+};
+function NonConcatenatedFormatStructure() {
+}
+function FormatterStructure() {
+}
+function SpacePaddedFormatter(formatter, padding) {
+  this.y58_1 = formatter;
+  this.z58_1 = padding;
+}
+protoOf(SpacePaddedFormatter).x58 = function (obj, builder, minusNotRequired) {
+  // Inline function 'kotlin.let' call
+  var it = StringBuilder_init_$Create$();
+  this.y58_1.x58(obj, it, minusNotRequired);
+  var string = it.toString();
+  // Inline function 'kotlin.repeat' call
+  var times = this.z58_1 - string.length | 0;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      builder.s(_Char___init__impl__6a9atx(32));
+    }
+     while (inductionVariable < times);
+  builder.f1(string);
+};
+function ConcatenatedFormatter(formatters) {
+  this.a59_1 = formatters;
+}
+protoOf(ConcatenatedFormatter).x58 = function (obj, builder, minusNotRequired) {
+  var _iterator__ex2g4s = this.a59_1.t();
+  while (_iterator__ex2g4s.u()) {
+    var formatter = _iterator__ex2g4s.v();
+    formatter.x58(obj, builder, minusNotRequired);
+  }
+};
+function UnsignedIntFormatterStructure(number, zeroPadding) {
+  this.b59_1 = number;
+  this.c59_1 = zeroPadding;
+  // Inline function 'kotlin.require' call
+  if (!(this.c59_1 >= 0)) {
+    var message = 'The minimum number of digits (' + this.c59_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(this.c59_1 <= 9)) {
+    var message_0 = 'The minimum number of digits (' + this.c59_1 + ') exceeds the length of an Int';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+protoOf(UnsignedIntFormatterStructure).x58 = function (obj, builder, minusNotRequired) {
+  var num = this.b59_1(obj);
+  var numberStr = num.toString();
+  // Inline function 'kotlin.repeat' call
+  var times = this.c59_1 - numberStr.length | 0;
+  var inductionVariable = 0;
+  if (inductionVariable < times)
+    do {
+      var index = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      builder.s(_Char___init__impl__6a9atx(48));
+    }
+     while (inductionVariable < times);
+  builder.f1(numberStr);
+};
+function SignedIntFormatterStructure(number, zeroPadding, outputPlusOnExceededWidth) {
+  this.d59_1 = number;
+  this.e59_1 = zeroPadding;
+  this.f59_1 = outputPlusOnExceededWidth;
+  // Inline function 'kotlin.require' call
+  if (!(this.e59_1 >= 0)) {
+    var message = 'The minimum number of digits (' + this.e59_1 + ') is negative';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!(this.e59_1 <= 9)) {
+    var message_0 = 'The minimum number of digits (' + this.e59_1 + ') exceeds the length of an Int';
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+protoOf(SignedIntFormatterStructure).x58 = function (obj, builder, minusNotRequired) {
+  var innerBuilder = StringBuilder_init_$Create$();
+  // Inline function 'kotlin.let' call
+  var it = this.d59_1(obj);
+  var number = minusNotRequired && it < 0 ? -it | 0 : it;
+  if (!(this.f59_1 == null) && number >= get_POWERS_OF_TEN()[this.f59_1]) {
+    innerBuilder.s(_Char___init__impl__6a9atx(43));
+  }
+  // Inline function 'kotlin.math.absoluteValue' call
+  if (abs(number) < get_POWERS_OF_TEN()[this.e59_1 - 1 | 0]) {
+    if (number >= 0) {
+      innerBuilder.zb(number + get_POWERS_OF_TEN()[this.e59_1] | 0).ec(0);
+    } else {
+      innerBuilder.zb(number - get_POWERS_OF_TEN()[this.e59_1] | 0).ec(1);
+    }
+  } else {
+    innerBuilder.zb(number);
+  }
+  builder.f1(innerBuilder);
+};
+function ConstantStringFormatterStructure(string) {
+  this.g59_1 = string;
+}
+protoOf(ConstantStringFormatterStructure).x58 = function (obj, builder, minusNotRequired) {
+  builder.f1(this.g59_1);
+};
+function ConstantNumberConsumer(expected) {
+  NumberConsumer.call(this, expected.length, 'the predefined string ' + expected);
+  this.j59_1 = expected;
+}
+protoOf(ConstantNumberConsumer).k59 = function (storage, input, start, end) {
+  var tmp;
+  // Inline function 'kotlin.text.substring' call
+  if (toString(charSequenceSubSequence(input, start, end)) === this.j59_1) {
+    tmp = null;
+  } else {
+    tmp = new WrongConstant(this.j59_1);
+  }
+  return tmp;
+};
+function NumberConsumer(length, whatThisExpects) {
+  this.l59_1 = length;
+  this.m59_1 = whatThisExpects;
+}
+protoOf(NumberConsumer).a = function () {
+  return this.l59_1;
+};
+function ExpectedInt() {
+}
+protoOf(ExpectedInt).n59 = function () {
+  return 'expected an Int value';
+};
+var ExpectedInt_instance;
+function ExpectedInt_getInstance() {
+  return ExpectedInt_instance;
+}
+function TooManyDigits(maxDigits) {
+  this.o59_1 = maxDigits;
+}
+protoOf(TooManyDigits).n59 = function () {
+  return 'expected at most ' + this.o59_1 + ' digits';
+};
+function TooFewDigits(minDigits) {
+  this.p59_1 = minDigits;
+}
+protoOf(TooFewDigits).n59 = function () {
+  return 'expected at least ' + this.p59_1 + ' digits';
+};
+function WrongConstant(expected) {
+  this.q59_1 = expected;
+}
+protoOf(WrongConstant).n59 = function () {
+  return "expected '" + this.q59_1 + "'";
+};
+function Conflicting(conflicting) {
+  this.r59_1 = conflicting;
+}
+protoOf(Conflicting).n59 = function () {
+  return "attempted to overwrite the existing value '" + toString(this.r59_1) + "'";
+};
+function setWithoutReassigning(_this__u8e3s4, receiver, value) {
+  var tmp0_elvis_lhs = _this__u8e3s4.t58(receiver, value);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var conflictingValue = tmp;
+  return new Conflicting(conflictingValue);
+}
+function UnsignedIntConsumer(minLength, maxLength, setter, name, multiplyByMinus1) {
+  multiplyByMinus1 = multiplyByMinus1 === VOID ? false : multiplyByMinus1;
+  NumberConsumer.call(this, minLength == maxLength ? minLength : null, name);
+  this.u59_1 = minLength;
+  this.v59_1 = maxLength;
+  this.w59_1 = setter;
+  this.x59_1 = multiplyByMinus1;
+  // Inline function 'kotlin.require' call
+  if (!(this.a() == null || numberRangeToNumber(1, 9).vh(this.a()))) {
+    var message = 'Invalid length for field ' + this.m59_1 + ': ' + this.a();
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+}
+protoOf(UnsignedIntConsumer).k59 = function (storage, input, start, end) {
+  var tmp;
+  if (!(this.v59_1 == null) && (end - start | 0) > this.v59_1) {
+    tmp = new TooManyDigits(this.v59_1);
+  } else if (!(this.u59_1 == null) && (end - start | 0) < this.u59_1) {
+    tmp = new TooFewDigits(this.u59_1);
+  } else {
+    var result = parseAsciiIntOrNull(input, start, end);
+    tmp = result == null ? ExpectedInt_instance : setWithoutReassigning(this.w59_1, storage, this.x59_1 ? -result | 0 : result);
+  }
+  return tmp;
+};
+function parseAsciiIntOrNull(_this__u8e3s4, start, end) {
+  var result = 0;
+  var inductionVariable = start;
+  if (inductionVariable < end)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var digit = charSequenceGet(_this__u8e3s4, i);
+      result = imul(result, 10) + asciiDigitToInt(digit) | 0;
+      if (result < 0)
+        return null;
+    }
+     while (inductionVariable < end);
+  return result;
+}
+function ParseError(position, message) {
+  this.y59_1 = position;
+  this.z59_1 = message;
+}
+function _ParseResult___init__impl__gvz3cn(value) {
+  return value;
+}
+function _ParseResult___get_value__impl__86mnxf($this) {
+  return $this;
+}
+function Companion_6() {
+}
+protoOf(Companion_6).a5a = function (indexOfNextUnparsed) {
+  return _ParseResult___init__impl__gvz3cn(indexOfNextUnparsed);
+};
+protoOf(Companion_6).b5a = function (position, message) {
+  return _ParseResult___init__impl__gvz3cn(new ParseError(position, message));
+};
+var Companion_instance_6;
+function Companion_getInstance_6() {
+  return Companion_instance_6;
+}
+function _Parser___init__impl__gdyfby(commands) {
+  return commands;
+}
+function _get_commands__a20n1($this) {
+  return $this;
+}
+function Parser__match_impl_nzt83d($this, input, initialContainer, startIndex) {
+  // Inline function 'kotlin.collections.mutableListOf' call
+  var errors = ArrayList_init_$Create$();
+  // Inline function 'kotlinx.datetime.internal.format.parser.Parser.parse' call
+  var parseOptions = mutableListOf([new ParserState(initialContainer, _get_commands__a20n1($this), startIndex)]);
+  iterate_over_alternatives: while (true) {
+    var tmp0_elvis_lhs = removeLastOrNull(parseOptions);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      break iterate_over_alternatives;
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var state = tmp;
+    var output = state.c5a_1.e56();
+    var inputPosition = state.e5a_1;
+    var parserStructure = state.d5a_1;
+    // Inline function 'kotlin.run' call
+    $l$block: {
+      var inductionVariable = 0;
+      var last = parserStructure.g5a_1.g1() - 1 | 0;
+      if (inductionVariable <= last)
+        do {
+          var ix = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          // Inline function 'kotlinx.datetime.internal.format.parser.ParseResult.match' call
+          var this_0 = parserStructure.g5a_1.h1(ix).i5a(output, input, inputPosition);
+          var tmp0_subject = _ParseResult___get_value__impl__86mnxf(this_0);
+          if (typeof tmp0_subject === 'number') {
+            inputPosition = _ParseResult___get_value__impl__86mnxf(this_0);
+          } else {
+            if (tmp0_subject instanceof ParseError) {
+              var it = _ParseResult___get_value__impl__86mnxf(this_0);
+              errors.e1(it);
+              break $l$block;
+            } else {
+              // Inline function 'kotlin.error' call
+              var message = 'Unexpected parse result: ' + toString(_ParseResult___get_value__impl__86mnxf(this_0));
+              throw IllegalStateException_init_$Create$(toString(message));
+            }
+          }
+        }
+         while (inductionVariable <= last);
+      if (parserStructure.h5a_1.r()) {
+        if (false || inputPosition === charSequenceLength(input)) {
+          return output;
+        } else {
+          var tmp_0 = inputPosition;
+          var it_0 = new ParseError(tmp_0, Parser$match$lambda);
+          errors.e1(it_0);
+        }
+      } else {
+        var inductionVariable_0 = parserStructure.h5a_1.g1() - 1 | 0;
+        if (0 <= inductionVariable_0)
+          do {
+            var ix_0 = inductionVariable_0;
+            inductionVariable_0 = inductionVariable_0 + -1 | 0;
+            parseOptions.e1(new ParserState(output, parserStructure.h5a_1.h1(ix_0), inputPosition));
+          }
+           while (0 <= inductionVariable_0);
+      }
+    }
+  }
+  // Inline function 'kotlin.collections.sortByDescending' call
+  if (errors.g1() > 1) {
+    // Inline function 'kotlin.comparisons.compareByDescending' call
+    var tmp_1 = Parser$match$lambda_0;
+    var tmp$ret$8 = new sam$kotlin_Comparator$0(tmp_1);
+    sortWith(errors, tmp$ret$8);
+  }
+  throw new ParseException(errors);
+}
+function Parser__match$default_impl_x2xlti($this, input, initialContainer, startIndex, $super) {
+  startIndex = startIndex === VOID ? 0 : startIndex;
+  var tmp;
+  if ($super === VOID) {
+    tmp = Parser__match_impl_nzt83d($this, input, initialContainer, startIndex);
+  } else {
+    var tmp_0 = $super;
+    tmp = (tmp_0 == null ? null : new Parser(tmp_0)).j5a.call(new Parser($this), input, initialContainer, startIndex);
+  }
+  return tmp;
+}
+function ParserState(output, parserStructure, inputPosition) {
+  this.c5a_1 = output;
+  this.d5a_1 = parserStructure;
+  this.e5a_1 = inputPosition;
+}
+function Parser__toString_impl_x33iea($this) {
+  return 'Parser(commands=' + $this.toString() + ')';
+}
+function Parser__hashCode_impl_bbxllf($this) {
+  return hashCode($this);
+}
+function Parser__equals_impl_djxokv($this, other) {
+  if (!(other instanceof Parser))
+    return false;
+  var tmp0_other_with_cast = other instanceof Parser ? other.f5a_1 : THROW_CCE();
+  if (!equals($this, tmp0_other_with_cast))
+    return false;
+  return true;
+}
+function sam$kotlin_Comparator$0(function_0) {
+  this.k5a_1 = function_0;
+}
+protoOf(sam$kotlin_Comparator$0).mc = function (a, b) {
+  return this.k5a_1(a, b);
+};
+protoOf(sam$kotlin_Comparator$0).compare = function (a, b) {
+  return this.mc(a, b);
+};
+protoOf(sam$kotlin_Comparator$0).g3 = function () {
+  return this.k5a_1;
+};
+protoOf(sam$kotlin_Comparator$0).equals = function (other) {
+  var tmp;
+  if (!(other == null) ? isInterface(other, Comparator) : false) {
+    var tmp_0;
+    if (!(other == null) ? isInterface(other, FunctionAdapter) : false) {
+      tmp_0 = equals(this.g3(), other.g3());
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(sam$kotlin_Comparator$0).hashCode = function () {
+  return hashCode(this.g3());
+};
+function Parser$match$lambda() {
+  return 'There is more input to consume';
+}
+function Parser$match$lambda_0(a, b) {
+  // Inline function 'kotlin.comparisons.compareValuesBy' call
+  var tmp = b.y59_1;
+  var tmp$ret$1 = a.y59_1;
+  return compareValues(tmp, tmp$ret$1);
+}
+function Parser(commands) {
+  this.f5a_1 = commands;
+}
+protoOf(Parser).toString = function () {
+  return Parser__toString_impl_x33iea(this.f5a_1);
+};
+protoOf(Parser).hashCode = function () {
+  return Parser__hashCode_impl_bbxllf(this.f5a_1);
+};
+protoOf(Parser).equals = function (other) {
+  return Parser__equals_impl_djxokv(this.f5a_1, other);
+};
+function ParserStructure(operations, followedBy) {
+  this.g5a_1 = operations;
+  this.h5a_1 = followedBy;
+}
+protoOf(ParserStructure).toString = function () {
+  return joinToString(this.g5a_1, ', ') + '(' + joinToString(this.h5a_1, ';') + ')';
+};
+function ParseException(errors) {
+  Exception_init_$Init$(formatError(errors), this);
+  captureStack(this, ParseException);
+}
+function concat(_this__u8e3s4) {
+  // Inline function 'kotlin.collections.foldRight' call
+  var accumulator = new ParserStructure(emptyList(), emptyList());
+  if (!_this__u8e3s4.r()) {
+    var iterator = _this__u8e3s4.i1(_this__u8e3s4.g1());
+    while (iterator.v4()) {
+      var tmp0 = iterator.x4();
+      var acc = accumulator;
+      accumulator = concat$append(tmp0, acc);
+    }
+  }
+  var naiveParser = accumulator;
+  return concat$simplify(naiveParser, emptyList());
+}
+function formatError(errors) {
+  if (errors.g1() === 1) {
+    return 'Position ' + errors.h1(0).y59_1 + ': ' + errors.h1(0).z59_1();
+  }
+  var averageMessageLength = 33;
+  var tmp0_buffer = StringBuilder_init_$Create$_0(imul(averageMessageLength, errors.g1()));
+  return joinTo(errors, tmp0_buffer, ', ', 'Errors: ', VOID, VOID, VOID, formatError$lambda).toString();
+}
+function concat$append(_this__u8e3s4, other) {
+  var tmp;
+  if (_this__u8e3s4.h5a_1.r()) {
+    tmp = new ParserStructure(plus(_this__u8e3s4.g5a_1, other.g5a_1), other.h5a_1);
+  } else {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = _this__u8e3s4.h5a_1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s = this_0.t();
+    while (_iterator__ex2g4s.u()) {
+      var item = _iterator__ex2g4s.v();
+      var tmp$ret$0 = concat$append(item, other);
+      destination.e1(tmp$ret$0);
+    }
+    tmp = new ParserStructure(_this__u8e3s4.g5a_1, destination);
+  }
+  return tmp;
+}
+function concat$simplify(_this__u8e3s4, unconditionalModifications) {
+  // Inline function 'kotlin.collections.mutableListOf' call
+  var newOperations = ArrayList_init_$Create$();
+  var currentNumberSpan = null;
+  var unconditionalModificationsForTails = toMutableList(unconditionalModifications);
+  var _iterator__ex2g4s = _this__u8e3s4.g5a_1.t();
+  while (_iterator__ex2g4s.u()) {
+    var op = _iterator__ex2g4s.v();
+    if (op instanceof NumberSpanParserOperation) {
+      if (!(currentNumberSpan == null)) {
+        currentNumberSpan.j1(op.l5a_1);
+      } else {
+        currentNumberSpan = toMutableList(op.l5a_1);
+      }
+    } else {
+      if (op instanceof UnconditionalModification) {
+        unconditionalModificationsForTails.e1(op);
+      } else {
+        if (!(currentNumberSpan == null)) {
+          newOperations.e1(new NumberSpanParserOperation(currentNumberSpan));
+          currentNumberSpan = null;
+        }
+        newOperations.e1(op);
+      }
+    }
+  }
+  // Inline function 'kotlin.collections.flatMap' call
+  var tmp0 = _this__u8e3s4.h5a_1;
+  // Inline function 'kotlin.collections.flatMapTo' call
+  var destination = ArrayList_init_$Create$();
+  var _iterator__ex2g4s_0 = tmp0.t();
+  while (_iterator__ex2g4s_0.u()) {
+    var element = _iterator__ex2g4s_0.v();
+    var simplified = concat$simplify(element, unconditionalModificationsForTails);
+    var tmp;
+    if (simplified.g5a_1.r()) {
+      // Inline function 'kotlin.collections.ifEmpty' call
+      var this_0 = simplified.h5a_1;
+      var tmp_0;
+      if (this_0.r()) {
+        tmp_0 = listOf(simplified);
+      } else {
+        tmp_0 = this_0;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = listOf(simplified);
+    }
+    var list = tmp;
+    addAll(destination, list);
+  }
+  // Inline function 'kotlin.collections.ifEmpty' call
+  var tmp_1;
+  if (destination.r()) {
+    tmp_1 = listOf(new ParserStructure(unconditionalModificationsForTails, emptyList()));
+  } else {
+    tmp_1 = destination;
+  }
+  var mergedTails = tmp_1;
+  var tmp_2;
+  if (currentNumberSpan == null) {
+    tmp_2 = new ParserStructure(newOperations, mergedTails);
+  } else {
+    var tmp$ret$8;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.none' call
+      var tmp_3;
+      if (isInterface(mergedTails, Collection)) {
+        tmp_3 = mergedTails.r();
+      } else {
+        tmp_3 = false;
+      }
+      if (tmp_3) {
+        tmp$ret$8 = true;
+        break $l$block_0;
+      }
+      var _iterator__ex2g4s_1 = mergedTails.t();
+      while (_iterator__ex2g4s_1.u()) {
+        var element_0 = _iterator__ex2g4s_1.v();
+        var tmp0_safe_receiver = firstOrNull(element_0.g5a_1);
+        var tmp_4;
+        if (tmp0_safe_receiver == null) {
+          tmp_4 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp_4 = tmp0_safe_receiver instanceof NumberSpanParserOperation;
+        }
+        if (tmp_4 === true) {
+          tmp$ret$8 = false;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$8 = true;
+    }
+    if (tmp$ret$8) {
+      newOperations.e1(new NumberSpanParserOperation(currentNumberSpan));
+      tmp_2 = new ParserStructure(newOperations, mergedTails);
+    } else {
+      // Inline function 'kotlin.collections.map' call
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(mergedTails, 10));
+      var _iterator__ex2g4s_2 = mergedTails.t();
+      while (_iterator__ex2g4s_2.u()) {
+        var item = _iterator__ex2g4s_2.v();
+        var firstOperation = firstOrNull(item.g5a_1);
+        var tmp_5;
+        if (firstOperation instanceof NumberSpanParserOperation) {
+          tmp_5 = new ParserStructure(plus(listOf(new NumberSpanParserOperation(plus(currentNumberSpan, firstOperation.l5a_1))), drop(item.g5a_1, 1)), item.h5a_1);
+        } else {
+          if (firstOperation == null) {
+            tmp_5 = new ParserStructure(listOf(new NumberSpanParserOperation(currentNumberSpan)), item.h5a_1);
+          } else {
+            tmp_5 = new ParserStructure(plus(listOf(new NumberSpanParserOperation(currentNumberSpan)), item.g5a_1), item.h5a_1);
+          }
+        }
+        var tmp$ret$12 = tmp_5;
+        destination_0.e1(tmp$ret$12);
+      }
+      var newTails = destination_0;
+      tmp_2 = new ParserStructure(newOperations, newTails);
+    }
+  }
+  return tmp_2;
+}
+function formatError$lambda(it) {
+  return 'position ' + it.y59_1 + ": '" + it.z59_1() + "'";
+}
+function spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name, withMinus) {
+  withMinus = withMinus === VOID ? false : withMinus;
+  var minNumberLength = (minDigits == null ? 1 : minDigits) + (withMinus ? 1 : 0) | 0;
+  var tmp;
+  if (maxDigits == null) {
+    tmp = null;
+  } else {
+    // Inline function 'kotlin.let' call
+    tmp = withMinus ? maxDigits + 1 | 0 : maxDigits;
+  }
+  var tmp2_elvis_lhs = tmp;
+  var maxNumberLength = tmp2_elvis_lhs == null ? 2147483647 : tmp2_elvis_lhs;
+  var spacePadding_0 = spacePadding == null ? 0 : spacePadding;
+  // Inline function 'kotlin.comparisons.minOf' call
+  var maxPaddedNumberLength = Math.min(maxNumberLength, spacePadding_0);
+  if (minNumberLength >= maxPaddedNumberLength)
+    return spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, minNumberLength, maxNumberLength);
+  var accumulated = spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, minNumberLength, minNumberLength);
+  var inductionVariable = minNumberLength;
+  if (inductionVariable < maxPaddedNumberLength)
+    do {
+      var accumulatedWidth = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      accumulated = new ParserStructure(emptyList(), listOf_0([spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, accumulatedWidth + 1 | 0, accumulatedWidth + 1 | 0), concat(listOf_0([new ParserStructure(listOf(new PlainStringParserOperation(' ')), emptyList()), accumulated]))]));
+    }
+     while (inductionVariable < maxPaddedNumberLength);
+  var tmp_0;
+  if (spacePadding_0 > maxNumberLength) {
+    var prepadding = new PlainStringParserOperation(repeat(' ', spacePadding_0 - maxNumberLength | 0));
+    tmp_0 = concat(listOf_0([new ParserStructure(listOf(prepadding), emptyList()), accumulated]));
+  } else if (spacePadding_0 === maxNumberLength) {
+    tmp_0 = accumulated;
+  } else {
+    var r = new ParserStructure(emptyList(), listOf_0([spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths(withMinus, setter, name, spacePadding_0 + 1 | 0, maxNumberLength), accumulated]));
+    tmp_0 = r;
+  }
+  return tmp_0;
+}
+function _get_whatThisExpects__4pg11j($this) {
+  // Inline function 'kotlin.collections.map' call
+  var this_0 = $this.l5a_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+  var _iterator__ex2g4s = this_0.t();
+  while (_iterator__ex2g4s.u()) {
+    var item = _iterator__ex2g4s.v();
+    var length = item.a();
+    var tmp$ret$0 = (length == null ? 'at least one digit' : '' + length + ' digits') + (' for ' + item.m59_1);
+    destination.e1(tmp$ret$0);
+  }
+  var consumerLengths = destination;
+  var tmp;
+  if ($this.n5a_1) {
+    tmp = 'a number with at least ' + $this.m5a_1 + ' digits: ' + toString(consumerLengths);
+  } else {
+    tmp = 'a number with exactly ' + $this.m5a_1 + ' digits: ' + toString(consumerLengths);
+  }
+  return tmp;
+}
+function NumberSpanParserOperation$consume$lambda(this$0) {
+  return function () {
+    return 'Unexpected end of input: yet to parse ' + _get_whatThisExpects__4pg11j(this$0);
+  };
+}
+function NumberSpanParserOperation$consume$lambda_0($digitsInRow, this$0) {
+  return function () {
+    return 'Only found ' + $digitsInRow._v + ' digits in a row, but need to parse ' + _get_whatThisExpects__4pg11j(this$0);
+  };
+}
+function NumberSpanParserOperation$consume$lambda_1($numberString, this$0, $i, $error) {
+  return function () {
+    return "Can not interpret the string '" + $numberString + "' as " + this$0.l5a_1.h1($i).m59_1 + ': ' + $error.n59();
+  };
+}
+function NumberSpanParserOperation(consumers) {
+  this.l5a_1 = consumers;
+  var tmp = this;
+  // Inline function 'kotlin.collections.sumOf' call
+  var sum = 0;
+  var _iterator__ex2g4s = this.l5a_1.t();
+  while (_iterator__ex2g4s.u()) {
+    var element = _iterator__ex2g4s.v();
+    var tmp_0 = sum;
+    var tmp0_elvis_lhs = element.a();
+    sum = tmp_0 + (tmp0_elvis_lhs == null ? 1 : tmp0_elvis_lhs) | 0;
+  }
+  tmp.m5a_1 = sum;
+  var tmp_1 = this;
+  var tmp0 = this.l5a_1;
+  var tmp$ret$2;
+  $l$block_0: {
+    // Inline function 'kotlin.collections.any' call
+    var tmp_2;
+    if (isInterface(tmp0, Collection)) {
+      tmp_2 = tmp0.r();
+    } else {
+      tmp_2 = false;
+    }
+    if (tmp_2) {
+      tmp$ret$2 = false;
+      break $l$block_0;
+    }
+    var _iterator__ex2g4s_0 = tmp0.t();
+    while (_iterator__ex2g4s_0.u()) {
+      var element_0 = _iterator__ex2g4s_0.v();
+      if (element_0.a() == null) {
+        tmp$ret$2 = true;
+        break $l$block_0;
+      }
+    }
+    tmp$ret$2 = false;
+  }
+  tmp_1.n5a_1 = tmp$ret$2;
+  var tmp0_0 = this.l5a_1;
+  var tmp$ret$4;
+  $l$block_2: {
+    // Inline function 'kotlin.collections.all' call
+    var tmp_3;
+    if (isInterface(tmp0_0, Collection)) {
+      tmp_3 = tmp0_0.r();
+    } else {
+      tmp_3 = false;
+    }
+    if (tmp_3) {
+      tmp$ret$4 = true;
+      break $l$block_2;
+    }
+    var _iterator__ex2g4s_1 = tmp0_0.t();
+    while (_iterator__ex2g4s_1.u()) {
+      var element_1 = _iterator__ex2g4s_1.v();
+      var tmp0_elvis_lhs_0 = element_1.a();
+      if (!((tmp0_elvis_lhs_0 == null ? 2147483647 : tmp0_elvis_lhs_0) > 0)) {
+        tmp$ret$4 = false;
+        break $l$block_2;
+      }
+    }
+    tmp$ret$4 = true;
+  }
+  // Inline function 'kotlin.require' call
+  // Inline function 'kotlin.require' call
+  if (!tmp$ret$4) {
+    var message = 'Failed requirement.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  var tmp0_1 = this.l5a_1;
+  var tmp$ret$9;
+  $l$block_3: {
+    // Inline function 'kotlin.collections.count' call
+    var tmp_4;
+    if (isInterface(tmp0_1, Collection)) {
+      tmp_4 = tmp0_1.r();
+    } else {
+      tmp_4 = false;
+    }
+    if (tmp_4) {
+      tmp$ret$9 = 0;
+      break $l$block_3;
+    }
+    var count = 0;
+    var _iterator__ex2g4s_2 = tmp0_1.t();
+    while (_iterator__ex2g4s_2.u()) {
+      var element_2 = _iterator__ex2g4s_2.v();
+      if (element_2.a() == null) {
+        count = count + 1 | 0;
+        checkCountOverflow(count);
+      }
+    }
+    tmp$ret$9 = count;
+  }
+  // Inline function 'kotlin.require' call
+  if (!(tmp$ret$9 <= 1)) {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_2 = this.l5a_1;
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$();
+    var _iterator__ex2g4s_3 = tmp0_2.t();
+    while (_iterator__ex2g4s_3.u()) {
+      var element_3 = _iterator__ex2g4s_3.v();
+      if (element_3.a() == null) {
+        destination.e1(element_3);
+      }
+    }
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(destination, 10));
+    var _iterator__ex2g4s_4 = destination.t();
+    while (_iterator__ex2g4s_4.u()) {
+      var item = _iterator__ex2g4s_4.v();
+      var tmp$ret$14 = item.m59_1;
+      destination_0.e1(tmp$ret$14);
+    }
+    var fieldNames = destination_0;
+    var message_0 = 'At most one variable-length numeric field in a row is allowed, but got several: ' + toString(fieldNames) + '. ' + "Parsing is undefined: for example, with variable-length month number and variable-length day of month, '111' can be parsed as Jan 11th or Nov 1st.";
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+protoOf(NumberSpanParserOperation).i5a = function (storage, input, startIndex) {
+  if ((startIndex + this.m5a_1 | 0) > charSequenceLength(input)) {
+    var tmp = Companion_instance_6;
+    return tmp.b5a(startIndex, NumberSpanParserOperation$consume$lambda(this));
+  }
+  var digitsInRow = {_v: 0};
+  while ((startIndex + digitsInRow._v | 0) < charSequenceLength(input) && isAsciiDigit(charSequenceGet(input, startIndex + digitsInRow._v | 0))) {
+    digitsInRow._v = digitsInRow._v + 1 | 0;
+    digitsInRow._v;
+  }
+  if (digitsInRow._v < this.m5a_1) {
+    var tmp_0 = Companion_instance_6;
+    return tmp_0.b5a(startIndex, NumberSpanParserOperation$consume$lambda_0(digitsInRow, this));
+  }
+  var index = startIndex;
+  var inductionVariable = 0;
+  var last = this.l5a_1.g1() - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      var tmp0_elvis_lhs = this.l5a_1.h1(i).a();
+      var length = tmp0_elvis_lhs == null ? (digitsInRow._v - this.m5a_1 | 0) + 1 | 0 : tmp0_elvis_lhs;
+      var error = this.l5a_1.h1(i).k59(storage, input, index, index + length | 0);
+      if (!(error == null)) {
+        var tmp2 = index;
+        // Inline function 'kotlin.text.substring' call
+        var endIndex = index + length | 0;
+        var numberString = toString(charSequenceSubSequence(input, tmp2, endIndex));
+        var tmp_1 = Companion_instance_6;
+        var tmp_2 = index;
+        return tmp_1.b5a(tmp_2, NumberSpanParserOperation$consume$lambda_1(numberString, this, i, error));
+      }
+      index = index + length | 0;
+    }
+     while (inductionVariable <= last);
+  return Companion_instance_6.a5a(index);
+};
+protoOf(NumberSpanParserOperation).toString = function () {
+  return _get_whatThisExpects__4pg11j(this);
+};
+function SignedIntParser(minDigits, maxDigits, spacePadding, setter, name, plusOnExceedsWidth) {
+  var parsers = mutableListOf([spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name, true)]);
+  if (!(plusOnExceedsWidth == null)) {
+    parsers.e1(spaceAndZeroPaddedUnsignedInt(minDigits, plusOnExceedsWidth, spacePadding, setter, name));
+    parsers.e1(new ParserStructure(listOf_0([new PlainStringParserOperation('+'), new NumberSpanParserOperation(listOf(new UnsignedIntConsumer(plusOnExceedsWidth + 1 | 0, maxDigits, setter, name, false)))]), emptyList()));
+  } else {
+    parsers.e1(spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name));
+  }
+  return new ParserStructure(emptyList(), parsers);
+}
+function PlainStringParserOperation$consume$lambda(this$0) {
+  return function () {
+    return "Unexpected end of input: yet to parse '" + this$0.o5a_1 + "'";
+  };
+}
+function PlainStringParserOperation$consume$lambda_0(this$0, $input, $startIndex, $i) {
+  return function () {
+    var tmp0 = $input;
+    var tmp2 = $startIndex;
+    // Inline function 'kotlin.text.substring' call
+    var endIndex = ($startIndex + $i | 0) + 1 | 0;
+    var tmp$ret$0 = toString(charSequenceSubSequence(tmp0, tmp2, endIndex));
+    return 'Expected ' + this$0.o5a_1 + ' but got ' + tmp$ret$0;
+  };
+}
+function PlainStringParserOperation(string) {
+  this.o5a_1 = string;
+  // Inline function 'kotlin.text.isNotEmpty' call
+  var this_0 = this.o5a_1;
+  // Inline function 'kotlin.require' call
+  if (!(charSequenceLength(this_0) > 0)) {
+    var message = 'Empty string is not allowed';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.require' call
+  if (!!isAsciiDigit(charCodeAt(this.o5a_1, 0))) {
+    var message_0 = "String '" + this.o5a_1 + "' starts with a digit";
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  // Inline function 'kotlin.require' call
+  if (!!isAsciiDigit(charCodeAt(this.o5a_1, this.o5a_1.length - 1 | 0))) {
+    var message_1 = "String '" + this.o5a_1 + "' ends with a digit";
+    throw IllegalArgumentException_init_$Create$(toString(message_1));
+  }
+}
+protoOf(PlainStringParserOperation).i5a = function (storage, input, startIndex) {
+  if ((startIndex + this.o5a_1.length | 0) > charSequenceLength(input)) {
+    var tmp = Companion_instance_6;
+    return tmp.b5a(startIndex, PlainStringParserOperation$consume$lambda(this));
+  }
+  var inductionVariable = 0;
+  var last = charSequenceLength(this.o5a_1) - 1 | 0;
+  if (inductionVariable <= last)
+    do {
+      var i = inductionVariable;
+      inductionVariable = inductionVariable + 1 | 0;
+      if (!(charSequenceGet(input, startIndex + i | 0) === charCodeAt(this.o5a_1, i))) {
+        var tmp_0 = Companion_instance_6;
+        return tmp_0.b5a(startIndex, PlainStringParserOperation$consume$lambda_0(this, input, startIndex, i));
+      }
+    }
+     while (inductionVariable <= last);
+  return Companion_instance_6.a5a(startIndex + this.o5a_1.length | 0);
+};
+protoOf(PlainStringParserOperation).toString = function () {
+  return "'" + this.o5a_1 + "'";
+};
+function UnconditionalModification() {
+}
+function spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths($withMinus, $setter, $name, minNumberLength, maxNumberLength) {
+  // Inline function 'kotlin.check' call
+  if (!(maxNumberLength >= (1 + ($withMinus ? 1 : 0) | 0))) {
+    throw IllegalStateException_init_$Create$('Check failed.');
+  }
+  // Inline function 'kotlin.collections.buildList' call
+  // Inline function 'kotlin.collections.buildListInternal' call
+  // Inline function 'kotlin.apply' call
+  var this_0 = ArrayList_init_$Create$();
+  if ($withMinus) {
+    this_0.e1(new PlainStringParserOperation('-'));
+  }
+  this_0.e1(new NumberSpanParserOperation(listOf(new UnsignedIntConsumer(minNumberLength - ($withMinus ? 1 : 0) | 0, maxNumberLength - ($withMinus ? 1 : 0) | 0, $setter, $name, $withMinus))));
+  var tmp$ret$4 = this_0.j3();
+  return new ParserStructure(tmp$ret$4, emptyList());
+}
+function get_POWERS_OF_TEN() {
+  _init_properties_math_kt__tgcmt4();
+  return POWERS_OF_TEN;
+}
+var POWERS_OF_TEN;
+var properties_initialized_math_kt_amm9wq;
+function _init_properties_math_kt__tgcmt4() {
+  if (!properties_initialized_math_kt_amm9wq) {
+    properties_initialized_math_kt_amm9wq = true;
+    // Inline function 'kotlin.intArrayOf' call
+    POWERS_OF_TEN = new Int32Array([1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000]);
+  }
+}
+function isAsciiDigit(_this__u8e3s4) {
+  return _Char___init__impl__6a9atx(48) <= _this__u8e3s4 ? _this__u8e3s4 <= _Char___init__impl__6a9atx(57) : false;
+}
+function asciiDigitToInt(_this__u8e3s4) {
+  return Char__minus_impl_a2frrh(_this__u8e3s4, _Char___init__impl__6a9atx(48));
+}
+function TimeBasedDateTimeUnitSerializer$descriptor$delegate$lambda() {
+  return buildClassSerialDescriptor('kotlinx.datetime.TimeBased', [], TimeBasedDateTimeUnitSerializer$descriptor$delegate$lambda$lambda);
+}
+function TimeBasedDateTimeUnitSerializer$descriptor$delegate$lambda$lambda($this$buildClassSerialDescriptor) {
+  // Inline function 'kotlinx.serialization.descriptors.element' call
+  var elementName = 'nanoseconds';
+  var annotations = emptyList();
+  // Inline function 'kotlinx.serialization.serializer' call
+  // Inline function 'kotlinx.serialization.internal.cast' call
+  var this_0 = serializer(createKType(PrimitiveClasses_getInstance().jb(), arrayOf([]), false));
+  var descriptor = (isInterface(this_0, KSerializer) ? this_0 : THROW_CCE()).z1r();
+  $this$buildClassSerialDescriptor.j1u(elementName, descriptor, annotations, false);
+  return Unit_instance;
+}
+function TimeBasedDateTimeUnitSerializer$_get_descriptor_$ref_ezonyw() {
+  return function (p0) {
+    return p0.z1r();
+  };
+}
+function TimeBasedDateTimeUnitSerializer() {
+  TimeBasedDateTimeUnitSerializer_instance = this;
+  var tmp = this;
+  var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+  tmp.p5a_1 = lazy_0(tmp_0, TimeBasedDateTimeUnitSerializer$descriptor$delegate$lambda);
+}
+protoOf(TimeBasedDateTimeUnitSerializer).z1r = function () {
+  var tmp0 = this.p5a_1;
+  var tmp = KProperty1;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('descriptor', 1, tmp, TimeBasedDateTimeUnitSerializer$_get_descriptor_$ref_ezonyw(), null);
+  return tmp0.m1();
+};
+protoOf(TimeBasedDateTimeUnitSerializer).q5a = function (encoder, value) {
+  // Inline function 'kotlinx.serialization.encoding.encodeStructure' call
+  var descriptor = this.z1r();
+  var composite = encoder.n1v(descriptor);
+  composite.y1w(TimeBasedDateTimeUnitSerializer_getInstance().z1r(), 0, value.s53_1);
+  composite.o1v(descriptor);
+};
+protoOf(TimeBasedDateTimeUnitSerializer).a1s = function (encoder, value) {
+  return this.q5a(encoder, value instanceof TimeBased ? value : THROW_CCE());
+};
+protoOf(TimeBasedDateTimeUnitSerializer).b1s = function (decoder) {
+  var seen = {_v: false};
+  var nanoseconds = {_v: 0n};
+  // Inline function 'kotlinx.serialization.encoding.decodeStructure' call
+  var descriptor = this.z1r();
+  var composite = decoder.n1v(descriptor);
+  if (composite.d1w()) {
+    nanoseconds._v = composite.t1v(TimeBasedDateTimeUnitSerializer_getInstance().z1r(), 0);
+    seen._v = true;
+  } else {
+    loop: while (true) {
+      var elementIndex = composite.e1w(TimeBasedDateTimeUnitSerializer_getInstance().z1r());
+      switch (elementIndex) {
+        case 0:
+          nanoseconds._v = composite.t1v(TimeBasedDateTimeUnitSerializer_getInstance().z1r(), 0);
+          seen._v = true;
+          break;
+        case -1:
+          break loop;
+        default:
+          throwUnknownIndexException(elementIndex);
+          break;
+      }
+    }
+  }
+  var result = Unit_instance;
+  composite.o1v(descriptor);
+  if (!seen._v)
+    throw MissingFieldException_init_$Create$('nanoseconds', this.z1r().a1t());
+  return new TimeBased(nanoseconds._v);
+};
+var TimeBasedDateTimeUnitSerializer_instance;
+function TimeBasedDateTimeUnitSerializer_getInstance() {
+  if (TimeBasedDateTimeUnitSerializer_instance == null)
+    new TimeBasedDateTimeUnitSerializer();
+  return TimeBasedDateTimeUnitSerializer_instance;
+}
+function _get_impl__d88w17($this) {
+  var tmp0 = $this.r5a_1;
+  var tmp = KProperty1;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('impl', 1, tmp, DateBasedDateTimeUnitSerializer$_get_impl_$ref_m860rs(), null);
+  return tmp0.m1();
+}
+function DateBasedDateTimeUnitSerializer$impl$delegate$lambda() {
+  var tmp = getKClass(DateBased);
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_0 = [getKClass(DayBased), getKClass(MonthBased)];
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp$ret$5 = [DayBasedDateTimeUnitSerializer_getInstance(), MonthBasedDateTimeUnitSerializer_getInstance()];
+  return new SealedClassSerializer('kotlinx.datetime.DateTimeUnit.DateBased', tmp, tmp_0, tmp$ret$5);
+}
+function DateBasedDateTimeUnitSerializer$_get_impl_$ref_m860rs() {
+  return function (p0) {
+    return _get_impl__d88w17(p0);
+  };
+}
+function DateBasedDateTimeUnitSerializer() {
+  DateBasedDateTimeUnitSerializer_instance = this;
+  AbstractPolymorphicSerializer.call(this);
+  var tmp = this;
+  var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+  tmp.r5a_1 = lazy_0(tmp_0, DateBasedDateTimeUnitSerializer$impl$delegate$lambda);
+}
+protoOf(DateBasedDateTimeUnitSerializer).c1s = function (decoder, klassName) {
+  return _get_impl__d88w17(this).c1s(decoder, klassName);
+};
+protoOf(DateBasedDateTimeUnitSerializer).s5a = function (encoder, value) {
+  return _get_impl__d88w17(this).e1s(encoder, value);
+};
+protoOf(DateBasedDateTimeUnitSerializer).e1s = function (encoder, value) {
+  return this.s5a(encoder, value instanceof DateBased ? value : THROW_CCE());
+};
+protoOf(DateBasedDateTimeUnitSerializer).d1s = function () {
+  return getKClass(DateBased);
+};
+protoOf(DateBasedDateTimeUnitSerializer).z1r = function () {
+  return _get_impl__d88w17(this).z1r();
+};
+var DateBasedDateTimeUnitSerializer_instance;
+function DateBasedDateTimeUnitSerializer_getInstance() {
+  if (DateBasedDateTimeUnitSerializer_instance == null)
+    new DateBasedDateTimeUnitSerializer();
+  return DateBasedDateTimeUnitSerializer_instance;
+}
+function DayBasedDateTimeUnitSerializer$descriptor$delegate$lambda() {
+  return buildClassSerialDescriptor('kotlinx.datetime.DayBased', [], DayBasedDateTimeUnitSerializer$descriptor$delegate$lambda$lambda);
+}
+function DayBasedDateTimeUnitSerializer$descriptor$delegate$lambda$lambda($this$buildClassSerialDescriptor) {
+  // Inline function 'kotlinx.serialization.descriptors.element' call
+  var annotations = emptyList();
+  // Inline function 'kotlinx.serialization.serializer' call
+  // Inline function 'kotlinx.serialization.internal.cast' call
+  var this_0 = serializer(createKType(PrimitiveClasses_getInstance().ib(), arrayOf([]), false));
+  var descriptor = (isInterface(this_0, KSerializer) ? this_0 : THROW_CCE()).z1r();
+  $this$buildClassSerialDescriptor.j1u('days', descriptor, annotations, false);
+  return Unit_instance;
+}
+function DayBasedDateTimeUnitSerializer$_get_descriptor_$ref_2ycvl3() {
+  return function (p0) {
+    return p0.z1r();
+  };
+}
+function DayBasedDateTimeUnitSerializer() {
+  DayBasedDateTimeUnitSerializer_instance = this;
+  var tmp = this;
+  var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+  tmp.t5a_1 = lazy_0(tmp_0, DayBasedDateTimeUnitSerializer$descriptor$delegate$lambda);
+}
+protoOf(DayBasedDateTimeUnitSerializer).z1r = function () {
+  var tmp0 = this.t5a_1;
+  var tmp = KProperty1;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('descriptor', 1, tmp, DayBasedDateTimeUnitSerializer$_get_descriptor_$ref_2ycvl3(), null);
+  return tmp0.m1();
+};
+protoOf(DayBasedDateTimeUnitSerializer).u5a = function (encoder, value) {
+  // Inline function 'kotlinx.serialization.encoding.encodeStructure' call
+  var descriptor = this.z1r();
+  var composite = encoder.n1v(descriptor);
+  composite.x1w(DayBasedDateTimeUnitSerializer_getInstance().z1r(), 0, value.y53_1);
+  composite.o1v(descriptor);
+};
+protoOf(DayBasedDateTimeUnitSerializer).a1s = function (encoder, value) {
+  return this.u5a(encoder, value instanceof DayBased ? value : THROW_CCE());
+};
+protoOf(DayBasedDateTimeUnitSerializer).b1s = function (decoder) {
+  var seen = {_v: false};
+  var days = {_v: 0};
+  // Inline function 'kotlinx.serialization.encoding.decodeStructure' call
+  var descriptor = this.z1r();
+  var composite = decoder.n1v(descriptor);
+  if (composite.d1w()) {
+    days._v = composite.s1v(DayBasedDateTimeUnitSerializer_getInstance().z1r(), 0);
+    seen._v = true;
+  } else {
+    loop: while (true) {
+      var elementIndex = composite.e1w(DayBasedDateTimeUnitSerializer_getInstance().z1r());
+      switch (elementIndex) {
+        case 0:
+          days._v = composite.s1v(DayBasedDateTimeUnitSerializer_getInstance().z1r(), 0);
+          seen._v = true;
+          break;
+        case -1:
+          break loop;
+        default:
+          throwUnknownIndexException(elementIndex);
+          break;
+      }
+    }
+  }
+  var result = Unit_instance;
+  composite.o1v(descriptor);
+  if (!seen._v)
+    throw MissingFieldException_init_$Create$('days', this.z1r().a1t());
+  return new DayBased(days._v);
+};
+var DayBasedDateTimeUnitSerializer_instance;
+function DayBasedDateTimeUnitSerializer_getInstance() {
+  if (DayBasedDateTimeUnitSerializer_instance == null)
+    new DayBasedDateTimeUnitSerializer();
+  return DayBasedDateTimeUnitSerializer_instance;
+}
+function MonthBasedDateTimeUnitSerializer$descriptor$delegate$lambda() {
+  return buildClassSerialDescriptor('kotlinx.datetime.MonthBased', [], MonthBasedDateTimeUnitSerializer$descriptor$delegate$lambda$lambda);
+}
+function MonthBasedDateTimeUnitSerializer$descriptor$delegate$lambda$lambda($this$buildClassSerialDescriptor) {
+  // Inline function 'kotlinx.serialization.descriptors.element' call
+  var annotations = emptyList();
+  // Inline function 'kotlinx.serialization.serializer' call
+  // Inline function 'kotlinx.serialization.internal.cast' call
+  var this_0 = serializer(createKType(PrimitiveClasses_getInstance().ib(), arrayOf([]), false));
+  var descriptor = (isInterface(this_0, KSerializer) ? this_0 : THROW_CCE()).z1r();
+  $this$buildClassSerialDescriptor.j1u('months', descriptor, annotations, false);
+  return Unit_instance;
+}
+function MonthBasedDateTimeUnitSerializer$_get_descriptor_$ref_vroatn() {
+  return function (p0) {
+    return p0.z1r();
+  };
+}
+function MonthBasedDateTimeUnitSerializer() {
+  MonthBasedDateTimeUnitSerializer_instance = this;
+  var tmp = this;
+  var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+  tmp.v5a_1 = lazy_0(tmp_0, MonthBasedDateTimeUnitSerializer$descriptor$delegate$lambda);
+}
+protoOf(MonthBasedDateTimeUnitSerializer).z1r = function () {
+  var tmp0 = this.v5a_1;
+  var tmp = KProperty1;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('descriptor', 1, tmp, MonthBasedDateTimeUnitSerializer$_get_descriptor_$ref_vroatn(), null);
+  return tmp0.m1();
+};
+protoOf(MonthBasedDateTimeUnitSerializer).w5a = function (encoder, value) {
+  // Inline function 'kotlinx.serialization.encoding.encodeStructure' call
+  var descriptor = this.z1r();
+  var composite = encoder.n1v(descriptor);
+  composite.x1w(MonthBasedDateTimeUnitSerializer_getInstance().z1r(), 0, value.z53_1);
+  composite.o1v(descriptor);
+};
+protoOf(MonthBasedDateTimeUnitSerializer).a1s = function (encoder, value) {
+  return this.w5a(encoder, value instanceof MonthBased ? value : THROW_CCE());
+};
+protoOf(MonthBasedDateTimeUnitSerializer).b1s = function (decoder) {
+  var seen = {_v: false};
+  var months = {_v: 0};
+  // Inline function 'kotlinx.serialization.encoding.decodeStructure' call
+  var descriptor = this.z1r();
+  var composite = decoder.n1v(descriptor);
+  if (composite.d1w()) {
+    months._v = composite.s1v(MonthBasedDateTimeUnitSerializer_getInstance().z1r(), 0);
+    seen._v = true;
+  } else {
+    loop: while (true) {
+      var elementIndex = composite.e1w(MonthBasedDateTimeUnitSerializer_getInstance().z1r());
+      switch (elementIndex) {
+        case 0:
+          months._v = composite.s1v(MonthBasedDateTimeUnitSerializer_getInstance().z1r(), 0);
+          seen._v = true;
+          break;
+        case -1:
+          break loop;
+        default:
+          throwUnknownIndexException(elementIndex);
+          break;
+      }
+    }
+  }
+  var result = Unit_instance;
+  composite.o1v(descriptor);
+  if (!seen._v)
+    throw MissingFieldException_init_$Create$('months', this.z1r().a1t());
+  return new MonthBased(months._v);
+};
+var MonthBasedDateTimeUnitSerializer_instance;
+function MonthBasedDateTimeUnitSerializer_getInstance() {
+  if (MonthBasedDateTimeUnitSerializer_instance == null)
+    new MonthBasedDateTimeUnitSerializer();
+  return MonthBasedDateTimeUnitSerializer_instance;
+}
+function _get_impl__d88w17_0($this) {
+  var tmp0 = $this.x5a_1;
+  var tmp = KProperty1;
+  // Inline function 'kotlin.getValue' call
+  getPropertyCallableRef('impl', 1, tmp, DateTimeUnitSerializer$_get_impl_$ref_2y1hvx(), null);
+  return tmp0.m1();
+}
+function DateTimeUnitSerializer$impl$delegate$lambda() {
+  var tmp = getKClass(DateTimeUnit);
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp_0 = [getKClass(DayBased), getKClass(MonthBased), getKClass(TimeBased)];
+  // Inline function 'kotlin.arrayOf' call
+  // Inline function 'kotlin.js.unsafeCast' call
+  // Inline function 'kotlin.js.asDynamic' call
+  var tmp$ret$5 = [DayBasedDateTimeUnitSerializer_getInstance(), MonthBasedDateTimeUnitSerializer_getInstance(), TimeBasedDateTimeUnitSerializer_getInstance()];
+  return new SealedClassSerializer('kotlinx.datetime.DateTimeUnit', tmp, tmp_0, tmp$ret$5);
+}
+function DateTimeUnitSerializer$_get_impl_$ref_2y1hvx() {
+  return function (p0) {
+    return _get_impl__d88w17_0(p0);
+  };
+}
+function DateTimeUnitSerializer() {
+  DateTimeUnitSerializer_instance = this;
+  AbstractPolymorphicSerializer.call(this);
+  var tmp = this;
+  var tmp_0 = LazyThreadSafetyMode_PUBLICATION_getInstance();
+  tmp.x5a_1 = lazy_0(tmp_0, DateTimeUnitSerializer$impl$delegate$lambda);
+}
+protoOf(DateTimeUnitSerializer).c1s = function (decoder, klassName) {
+  return _get_impl__d88w17_0(this).c1s(decoder, klassName);
+};
+protoOf(DateTimeUnitSerializer).y5a = function (encoder, value) {
+  return _get_impl__d88w17_0(this).e1s(encoder, value);
+};
+protoOf(DateTimeUnitSerializer).e1s = function (encoder, value) {
+  return this.y5a(encoder, value instanceof DateTimeUnit ? value : THROW_CCE());
+};
+protoOf(DateTimeUnitSerializer).d1s = function () {
+  return getKClass(DateTimeUnit);
+};
+protoOf(DateTimeUnitSerializer).z1r = function () {
+  return _get_impl__d88w17_0(this).z1r();
+};
+var DateTimeUnitSerializer_instance;
+function DateTimeUnitSerializer_getInstance() {
+  if (DateTimeUnitSerializer_instance == null)
+    new DateTimeUnitSerializer();
+  return DateTimeUnitSerializer_instance;
+}
+function throwUnknownIndexException(index) {
+  throw SerializationException_init_$Create$('An unknown field for index ' + index);
+}
+function LocalDateSerializer() {
+  LocalDateSerializer_instance = this;
+  this.z5a_1 = PrimitiveSerialDescriptor('kotlinx.datetime.LocalDate', STRING_getInstance());
+}
+protoOf(LocalDateSerializer).z1r = function () {
+  return this.z5a_1;
+};
+protoOf(LocalDateSerializer).b1s = function (decoder) {
+  return Companion_getInstance_7().e5b(decoder.i1v());
+};
+protoOf(LocalDateSerializer).f5b = function (encoder, value) {
+  encoder.r1w(value.toString());
+};
+protoOf(LocalDateSerializer).a1s = function (encoder, value) {
+  return this.f5b(encoder, value instanceof LocalDate ? value : THROW_CCE());
+};
+var LocalDateSerializer_instance;
+function LocalDateSerializer_getInstance() {
+  if (LocalDateSerializer_instance == null)
+    new LocalDateSerializer();
+  return LocalDateSerializer_instance;
+}
+function YearMonthSerializer() {
+  YearMonthSerializer_instance = this;
+  this.g5b_1 = PrimitiveSerialDescriptor('kotlinx.datetime.YearMonth', STRING_getInstance());
+}
+protoOf(YearMonthSerializer).z1r = function () {
+  return this.g5b_1;
+};
+protoOf(YearMonthSerializer).b1s = function (decoder) {
+  return Companion_instance_8.h5b(decoder.i1v());
+};
+protoOf(YearMonthSerializer).i5b = function (encoder, value) {
+  encoder.r1w(value.toString());
+};
+protoOf(YearMonthSerializer).a1s = function (encoder, value) {
+  return this.i5b(encoder, value instanceof YearMonth ? value : THROW_CCE());
+};
+var YearMonthSerializer_instance;
+function YearMonthSerializer_getInstance() {
+  if (YearMonthSerializer_instance == null)
+    new YearMonthSerializer();
+  return YearMonthSerializer_instance;
+}
+function Companion_7() {
+  Companion_instance_7 = this;
+  this.a5b_1 = new LocalDate(-999999999, 1, 1);
+  this.b5b_1 = new LocalDate(999999999, 12, 31);
+  this.c5b_1 = -365243219162n;
+  this.d5b_1 = 365241780471n;
+}
+protoOf(Companion_7).j5b = function (input, format) {
+  return format.al(input);
+};
+protoOf(Companion_7).e5b = function (input, format, $super) {
+  format = format === VOID ? getIsoDateFormat() : format;
+  return $super === VOID ? this.j5b(input, format) : $super.j5b.call(this, input, format);
+};
+protoOf(Companion_7).k5b = function (epochDays) {
+  // Inline function 'kotlin.require' call
+  if (!(-365243219162n <= epochDays ? epochDays <= 365241780471n : false)) {
+    var message = 'Invalid date: epoch day ' + epochDays.toString() + ' is outside the boundaries of LocalDate';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.Long.plus' call
+  var zeroDay = add(epochDays, fromInt(719528));
+  // Inline function 'kotlin.Long.minus' call
+  var this_0 = zeroDay;
+  zeroDay = subtract(this_0, fromInt(60));
+  var adjust = 0n;
+  if (zeroDay < 0n) {
+    // Inline function 'kotlin.Long.plus' call
+    var this_1 = zeroDay;
+    // Inline function 'kotlin.Long.div' call
+    var this_2 = add(this_1, fromInt(1));
+    // Inline function 'kotlin.Long.minus' call
+    var this_3 = divide(this_2, fromInt(146097));
+    var adjustCycles = subtract(this_3, fromInt(1));
+    // Inline function 'kotlin.Long.times' call
+    adjust = multiply(adjustCycles, fromInt(400));
+    var tmp = zeroDay;
+    // Inline function 'kotlin.Long.times' call
+    var this_4 = negate(adjustCycles);
+    var tmp$ret$8 = multiply(this_4, fromInt(146097));
+    zeroDay = add(tmp, tmp$ret$8);
+  }
+  // Inline function 'kotlin.Long.plus' call
+  var this_5 = multiply(numberToLong(400), zeroDay);
+  // Inline function 'kotlin.Long.div' call
+  var this_6 = add(this_5, fromInt(591));
+  var yearEst = divide(this_6, fromInt(146097));
+  var tmp_0 = zeroDay;
+  var tmp_1 = multiply(numberToLong(365), yearEst);
+  // Inline function 'kotlin.Long.div' call
+  var this_7 = yearEst;
+  var tmp$ret$11 = divide(this_7, fromInt(4));
+  var tmp_2 = add(tmp_1, tmp$ret$11);
+  // Inline function 'kotlin.Long.div' call
+  var this_8 = yearEst;
+  var tmp$ret$12 = divide(this_8, fromInt(100));
+  var tmp_3 = subtract(tmp_2, tmp$ret$12);
+  // Inline function 'kotlin.Long.div' call
+  var this_9 = yearEst;
+  var tmp$ret$13 = divide(this_9, fromInt(400));
+  var doyEst = subtract(tmp_0, add(tmp_3, tmp$ret$13));
+  if (doyEst < 0n) {
+    var _unary__edvuaz = yearEst;
+    yearEst = subtract(_unary__edvuaz, get_ONE());
+    var tmp_4 = zeroDay;
+    var tmp_5 = multiply(numberToLong(365), yearEst);
+    // Inline function 'kotlin.Long.div' call
+    var this_10 = yearEst;
+    var tmp$ret$14 = divide(this_10, fromInt(4));
+    var tmp_6 = add(tmp_5, tmp$ret$14);
+    // Inline function 'kotlin.Long.div' call
+    var this_11 = yearEst;
+    var tmp$ret$15 = divide(this_11, fromInt(100));
+    var tmp_7 = subtract(tmp_6, tmp$ret$15);
+    // Inline function 'kotlin.Long.div' call
+    var this_12 = yearEst;
+    var tmp$ret$16 = divide(this_12, fromInt(400));
+    doyEst = subtract(tmp_4, add(tmp_7, tmp$ret$16));
+  }
+  yearEst = add(yearEst, adjust);
+  var marchDoy0 = convertToInt(doyEst);
+  var marchMonth0 = (imul(marchDoy0, 5) + 2 | 0) / 153 | 0;
+  var month = ((marchMonth0 + 2 | 0) % 12 | 0) + 1 | 0;
+  var dom = (marchDoy0 - ((imul(marchMonth0, 306) + 5 | 0) / 10 | 0) | 0) + 1 | 0;
+  var tmp0 = yearEst;
+  // Inline function 'kotlin.Long.plus' call
+  var other = marchMonth0 / 10 | 0;
+  yearEst = add(tmp0, fromInt(other));
+  return new LocalDate(convertToInt(yearEst), month, dom);
+};
+var Companion_instance_7;
+function Companion_getInstance_7() {
+  if (Companion_instance_7 == null)
+    new Companion_7();
+  return Companion_instance_7;
+}
+function Formats() {
+  Formats_instance = this;
+  this.m54_1 = get_ISO_DATE_BASIC();
+}
+protoOf(Formats).n54 = function () {
+  return get_ISO_DATE();
+};
+var Formats_instance;
+function Formats_getInstance() {
+  if (Formats_instance == null)
+    new Formats();
+  return Formats_instance;
+}
+function resolvePreviousValid($this, year, month, day) {
+  // Inline function 'kotlin.math.min' call
+  var b = monthLength(month, isLeapYear(year));
+  var newDay = Math.min(day, b);
+  return new LocalDate(year, month, newDay);
+}
+function LocalDate(year, month, day) {
+  Companion_getInstance_7();
+  this.w55_1 = year;
+  this.x55_1 = day;
+  this.y55_1 = month;
+  // Inline function 'kotlin.require' call
+  if (!isValidYear(this.w55_1)) {
+    var message = 'Invalid date: the year is out of range';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  var containsArg = this.y55_1;
+  // Inline function 'kotlin.require' call
+  if (!(1 <= containsArg ? containsArg <= 12 : false)) {
+    var message_0 = 'Invalid date: month must be a number between 1 and 12, got ' + this.y55_1;
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+  var containsArg_0 = this.x55_1;
+  // Inline function 'kotlin.require' call
+  if (!(1 <= containsArg_0 ? containsArg_0 <= 31 : false)) {
+    var message_1 = 'Invalid date: day of month must be a number between 1 and 31, got ' + this.x55_1;
+    throw IllegalArgumentException_init_$Create$(toString(message_1));
+  }
+  if (this.x55_1 > 28 && this.x55_1 > monthLength(this.y55_1, isLeapYear(this.w55_1))) {
+    if (this.x55_1 === 29) {
+      throw IllegalArgumentException_init_$Create$("Invalid date 'February 29' as '" + this.w55_1 + "' is not a leap year");
+    } else {
+      throw IllegalArgumentException_init_$Create$("Invalid date '" + Month_0(month).toString() + ' ' + this.x55_1 + "'");
+    }
+  }
+}
+protoOf(LocalDate).l5b = function () {
+  var y = fromInt(this.w55_1);
+  var m = fromInt(this.y55_1);
+  var total = 0n;
+  total = add(total, multiply(numberToLong(365), y));
+  if (y >= 0n) {
+    var tmp = total;
+    // Inline function 'kotlin.Long.plus' call
+    // Inline function 'kotlin.Long.div' call
+    var this_0 = add(y, fromInt(3));
+    var tmp_0 = divide(this_0, fromInt(4));
+    // Inline function 'kotlin.Long.plus' call
+    // Inline function 'kotlin.Long.div' call
+    var this_1 = add(y, fromInt(99));
+    var tmp$ret$3 = divide(this_1, fromInt(100));
+    var tmp_1 = subtract(tmp_0, tmp$ret$3);
+    // Inline function 'kotlin.Long.plus' call
+    // Inline function 'kotlin.Long.div' call
+    var this_2 = add(y, fromInt(399));
+    var tmp$ret$5 = divide(this_2, fromInt(400));
+    total = add(tmp, add(tmp_1, tmp$ret$5));
+  } else {
+    var tmp_2 = total;
+    // Inline function 'kotlin.Long.div' call
+    var tmp_3 = divide(y, fromInt(-4));
+    // Inline function 'kotlin.Long.div' call
+    var tmp$ret$7 = divide(y, fromInt(-100));
+    var tmp_4 = subtract(tmp_3, tmp$ret$7);
+    // Inline function 'kotlin.Long.div' call
+    var tmp$ret$8 = divide(y, fromInt(-400));
+    total = subtract(tmp_2, add(tmp_4, tmp$ret$8));
+  }
+  var tmp_5 = total;
+  // Inline function 'kotlin.Long.minus' call
+  var this_3 = multiply(numberToLong(367), m);
+  // Inline function 'kotlin.Long.div' call
+  var this_4 = subtract(this_3, fromInt(362));
+  var tmp$ret$10 = divide(this_4, fromInt(12));
+  total = add(tmp_5, tmp$ret$10);
+  var tmp0 = total;
+  // Inline function 'kotlin.Long.plus' call
+  var other = this.x55_1 - 1 | 0;
+  total = add(tmp0, fromInt(other));
+  if (m > 2n) {
+    var _unary__edvuaz = total;
+    total = subtract(_unary__edvuaz, get_ONE());
+    if (!isLeapYear(this.w55_1)) {
+      var _unary__edvuaz_0 = total;
+      total = subtract(_unary__edvuaz_0, get_ONE());
+    }
+  }
+  // Inline function 'kotlin.Long.minus' call
+  var this_5 = total;
+  return subtract(this_5, fromInt(719528));
+};
+protoOf(LocalDate).z55 = function () {
+  return Month_0(this.y55_1);
+};
+protoOf(LocalDate).r55 = function () {
+  // Inline function 'kotlin.Long.plus' call
+  var this_0 = this.l5b();
+  // Inline function 'kotlin.mod' call
+  var tmp0 = add(this_0, fromInt(3));
+  // Inline function 'kotlin.mod' call
+  var other = fromInt(7);
+  var r = modulo(tmp0, other);
+  var tmp$ret$1 = add(r, other & shiftRight((r ^ other) & (r | negate(r)), 63));
+  var dow0 = convertToInt(tmp$ret$1);
+  return DayOfWeek_0(dow0 + 1 | 0);
+};
+protoOf(LocalDate).t55 = function () {
+  return (firstDayOfYear(this.z55(), isLeapYear(this.w55_1)) + this.x55_1 | 0) - 1 | 0;
+};
+protoOf(LocalDate).m5b = function (other) {
+  var y = compareTo(this.w55_1, other.w55_1);
+  if (!(y === 0)) {
+    return y;
+  }
+  var m = compareTo(this.y55_1, other.y55_1);
+  if (!(m === 0)) {
+    return m;
+  }
+  return compareTo(this.x55_1, other.x55_1);
+};
+protoOf(LocalDate).d = function (other) {
+  return this.m5b(other instanceof LocalDate ? other : THROW_CCE());
+};
+protoOf(LocalDate).n5b = function (monthsToAdd) {
+  if (monthsToAdd === 0n) {
+    return this;
+  }
+  var tmp0 = multiply(numberToLong(this.w55_1), 12n);
+  // Inline function 'kotlin.Long.plus' call
+  var other = this.y55_1 - 1 | 0;
+  var monthCount = add(tmp0, fromInt(other));
+  var calcMonths = safeAdd(monthCount, monthsToAdd);
+  // Inline function 'kotlin.floorDiv' call
+  // Inline function 'kotlin.floorDiv' call
+  var other_0 = fromInt(12);
+  var q = divide(calcMonths, other_0);
+  if ((calcMonths ^ other_0) < 0n && !(multiply(q, other_0) === calcMonths)) {
+    var _unary__edvuaz = q;
+    q = subtract(_unary__edvuaz, get_ONE());
+  }
+  var newYear = q;
+  // Inline function 'kotlin.ranges.contains' call
+  var this_0 = numberRangeToNumber(-999999999, 999999999);
+  if (!contains(isInterface(this_0, ClosedRange) ? this_0 : THROW_CCE(), newYear)) {
+    throw IllegalArgumentException_init_$Create$('The result of adding ' + monthsToAdd.toString() + ' months to ' + this.toString() + ' is out of LocalDate range.');
+  }
+  // Inline function 'kotlin.mod' call
+  // Inline function 'kotlin.mod' call
+  var other_1 = fromInt(12);
+  var r = modulo(calcMonths, other_1);
+  var tmp$ret$4 = add(r, other_1 & shiftRight((r ^ other_1) & (r | negate(r)), 63));
+  var newMonth = convertToInt(tmp$ret$4) + 1 | 0;
+  return resolvePreviousValid(this, convertToInt(newYear), newMonth, this.x55_1);
+};
+protoOf(LocalDate).o5b = function (daysToAdd) {
+  return daysToAdd === 0n ? this : Companion_getInstance_7().k5b(safeAdd(this.l5b(), daysToAdd));
+};
+protoOf(LocalDate).equals = function (other) {
+  var tmp;
+  if (this === other) {
+    tmp = true;
+  } else {
+    var tmp_0;
+    if (other instanceof LocalDate) {
+      tmp_0 = this.m5b(other) === 0;
+    } else {
+      tmp_0 = false;
+    }
+    tmp = tmp_0;
+  }
+  return tmp;
+};
+protoOf(LocalDate).hashCode = function () {
+  var yearValue = this.w55_1;
+  var monthValue = this.y55_1;
+  var dayValue = this.x55_1;
+  return yearValue & -2048 ^ (((yearValue << 11) + (monthValue << 6) | 0) + dayValue | 0);
+};
+protoOf(LocalDate).toString = function () {
+  return format(this, Formats_getInstance().n54());
+};
+function isValidYear(year) {
+  return year >= -999999999 && year <= 999999999;
+}
+function plus_1(_this__u8e3s4, value, unit) {
+  var tmp;
+  try {
+    var tmp_0;
+    if (unit instanceof DayBased) {
+      tmp_0 = _this__u8e3s4.o5b(safeMultiply(value, fromInt(unit.y53_1)));
+    } else {
+      if (unit instanceof MonthBased) {
+        tmp_0 = _this__u8e3s4.n5b(safeMultiply(value, fromInt(unit.z53_1)));
+      } else {
+        noWhenBranchMatchedException();
+      }
+    }
+    tmp = tmp_0;
+  } catch ($p) {
+    var tmp_1;
+    if ($p instanceof ArithmeticException) {
+      var e = $p;
+      throw DateTimeArithmeticException_init_$Create$_0('Arithmetic overflow when adding a value to a date', e);
+    } else {
+      if ($p instanceof IllegalArgumentException) {
+        var e_0 = $p;
+        throw DateTimeArithmeticException_init_$Create$_0('Boundaries of LocalDate exceeded when adding a value', e_0);
+      } else {
+        throw $p;
+      }
+    }
+  }
+  return tmp;
+}
+function firstDayOfYear(_this__u8e3s4, leapYear) {
+  var leap = leapYear ? 1 : 0;
+  var tmp;
+  switch (_this__u8e3s4.a1_1) {
+    case 0:
+      tmp = 1;
+      break;
+    case 1:
+      tmp = 32;
+      break;
+    case 2:
+      tmp = 60 + leap | 0;
+      break;
+    case 3:
+      tmp = 91 + leap | 0;
+      break;
+    case 4:
+      tmp = 121 + leap | 0;
+      break;
+    case 5:
+      tmp = 152 + leap | 0;
+      break;
+    case 6:
+      tmp = 182 + leap | 0;
+      break;
+    case 7:
+      tmp = 213 + leap | 0;
+      break;
+    case 8:
+      tmp = 244 + leap | 0;
+      break;
+    case 9:
+      tmp = 274 + leap | 0;
+      break;
+    case 10:
+      tmp = 305 + leap | 0;
+      break;
+    case 11:
+      tmp = 335 + leap | 0;
+      break;
+    default:
+      noWhenBranchMatchedException();
+      break;
+  }
+  return tmp;
+}
+function Companion_8() {
+}
+protoOf(Companion_8).p5b = function (input, format) {
+  return format.al(input);
+};
+protoOf(Companion_8).h5b = function (input, format, $super) {
+  format = format === VOID ? Formats_instance_0.n54() : format;
+  return $super === VOID ? this.p5b(input, format) : $super.p5b.call(this, input, format);
+};
+var Companion_instance_8;
+function Companion_getInstance_8() {
+  return Companion_instance_8;
+}
+function Formats_0() {
+}
+protoOf(Formats_0).n54 = function () {
+  return get_ISO_YEAR_MONTH();
+};
+var Formats_instance_0;
+function Formats_getInstance_0() {
+  return Formats_instance_0;
+}
+function YearMonth$_get_year_$ref_chp4n6() {
+  return function (p0) {
+    return p0.c57_1;
+  };
+}
+function YearMonth$_get_month_$ref_9rphhd() {
+  return function (p0) {
+    return p0.z55();
+  };
+}
+function YearMonth(year, month) {
+  this.c57_1 = year;
+  this.d57_1 = month;
+  // Inline function 'kotlin.require' call
+  if (!(1 <= month ? month <= 12 : false)) {
+    var message = 'Month must be in 1..12, but was ' + month;
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  var containsLower = Companion_getInstance_7().a5b_1.w55_1;
+  var containsUpper = Companion_getInstance_7().b5b_1.w55_1;
+  var containsArg = this.c57_1;
+  // Inline function 'kotlin.require' call
+  if (!(containsLower <= containsArg ? containsArg <= containsUpper : false)) {
+    var message_0 = 'Year ' + this.c57_1 + ' is out of range: ' + Companion_getInstance_7().a5b_1.w55_1 + '..' + Companion_getInstance_7().b5b_1.w55_1;
+    throw IllegalArgumentException_init_$Create$(toString(message_0));
+  }
+}
+protoOf(YearMonth).z55 = function () {
+  return Month_0(this.d57_1);
+};
+protoOf(YearMonth).q5b = function (other) {
+  var tmp = KProperty1;
+  var tmp_0 = getPropertyCallableRef('year', 1, tmp, YearMonth$_get_year_$ref_chp4n6(), null);
+  var tmp_1 = KProperty1;
+  return compareValuesBy(this, other, [tmp_0, getPropertyCallableRef('month', 1, tmp_1, YearMonth$_get_month_$ref_9rphhd(), null)]);
+};
+protoOf(YearMonth).d = function (other) {
+  return this.q5b(other instanceof YearMonth ? other : THROW_CCE());
+};
+protoOf(YearMonth).toString = function () {
+  return Formats_instance_0.n54().o54(this);
+};
+protoOf(YearMonth).equals = function (other) {
+  var tmp;
+  var tmp_0;
+  if (other instanceof YearMonth) {
+    tmp_0 = this.c57_1 === other.c57_1;
+  } else {
+    tmp_0 = false;
+  }
+  if (tmp_0) {
+    tmp = this.z55().equals(other.z55());
+  } else {
+    tmp = false;
+  }
+  return tmp;
+};
+protoOf(YearMonth).hashCode = function () {
+  return imul(this.c57_1, 31) + this.z55().hashCode() | 0;
+};
+function safeAdd(a, b) {
+  var sum = add(a, b);
+  if ((a ^ sum) < 0n && (a ^ b) >= 0n) {
+    throw ArithmeticException_init_$Create$('Addition overflows a long: ' + a.toString() + ' + ' + b.toString());
+  }
+  return sum;
+}
+function safeMultiply(a, b) {
+  if (b === 1n) {
+    return a;
+  }
+  if (a === 1n) {
+    return b;
+  }
+  if (a === 0n || b === 0n) {
+    return 0n;
+  }
+  var total = multiply(a, b);
+  if (!(divide(total, b) === a) || (a === -9223372036854775808n && b === -1n) || (b === -9223372036854775808n && a === -1n)) {
+    throw ArithmeticException_init_$Create$('Multiplication overflows a long: ' + a.toString() + ' * ' + b.toString());
+  }
+  return total;
+}
+function safeMultiply_0(a, b) {
+  var total = multiply(fromInt(a), fromInt(b));
+  if (total < -2147483648n || total > 2147483647n) {
+    throw ArithmeticException_init_$Create$('Multiplication overflows an int: ' + a + ' * ' + b);
+  }
+  return convertToInt(total);
+}
+//region block: post-declaration
+protoOf(Builder).d55 = chars;
+protoOf(Builder).i2l = build;
+protoOf(Builder).k56 = addFormatStructureForYearMonth;
+protoOf(Builder).e55 = day;
+protoOf(Builder).f55 = day$default;
+protoOf(Builder).z54 = year;
+protoOf(Builder).a55 = year$default;
+protoOf(Builder).b55 = monthNumber;
+protoOf(Builder).c55 = monthNumber$default;
+protoOf(Builder_0).d55 = chars;
+protoOf(Builder_0).i2l = build;
+protoOf(Builder_0).z54 = year;
+protoOf(Builder_0).a55 = year$default;
+protoOf(Builder_0).b55 = monthNumber;
+protoOf(Builder_0).c55 = monthNumber$default;
+protoOf(PropertyAccessor).c58 = getterNotNull;
+protoOf(SpacePaddedFormatter).x54 = format$default;
+protoOf(ConcatenatedFormatter).x54 = format$default;
+protoOf(UnsignedIntFormatterStructure).x54 = format$default;
+protoOf(SignedIntFormatterStructure).x54 = format$default;
+protoOf(ConstantStringFormatterStructure).x54 = format$default;
+//endregion
+//region block: init
+Companion_instance = new Companion();
+Companion_instance_0 = new Companion_0();
+Companion_instance_1 = new Companion_1();
+Companion_instance_2 = new Companion_2();
+Companion_instance_4 = new Companion_4();
+Companion_instance_5 = new Companion_5();
+ExpectedInt_instance = new ExpectedInt();
+Companion_instance_6 = new Companion_6();
+Companion_instance_8 = new Companion_8();
+Formats_instance_0 = new Formats_0();
+//endregion
+//region block: exports
+export {
+  LocalDateSerializer_getInstance as LocalDateSerializer_getInstance2mk9vo4hqcyvz,
+};
+//endregion
+
+//# sourceMappingURL=Kotlin-DateTime-library-kotlinx-datetime.mjs.map