@dhis2/expression-parser 1.1.5 → 1.1.6

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

@@ -0,0 +1,2619 @@
+(function (_, $module$_js_joda_core_gcv2k, kotlin_kotlin) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var LocalDate = $module$_js_joda_core_gcv2k.LocalDate;
+  var ChronoUnit = $module$_js_joda_core_gcv2k.ChronoUnit;
+  var LocalDateTime = $module$_js_joda_core_gcv2k.LocalDateTime;
+  var ZoneOffset = $module$_js_joda_core_gcv2k.ZoneOffset;
+  var ZoneId = $module$_js_joda_core_gcv2k.ZoneId;
+  var VOID = kotlin_kotlin.$_$.c;
+  var protoOf = kotlin_kotlin.$_$.y5;
+  var objectCreate = kotlin_kotlin.$_$.x5;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.h5;
+  var Long = kotlin_kotlin.$_$.y7;
+  var initMetadataForClass = kotlin_kotlin.$_$.g5;
+  var toLong = kotlin_kotlin.$_$.z5;
+  var StringBuilder_init_$Create$ = kotlin_kotlin.$_$.n;
+  var _Char___init__impl__6a9atx = kotlin_kotlin.$_$.f1;
+  var Unit_instance = kotlin_kotlin.$_$.n2;
+  var abs = kotlin_kotlin.$_$.b6;
+  var padStart = kotlin_kotlin.$_$.c7;
+  var numberRangeToNumber = kotlin_kotlin.$_$.s5;
+  var THROW_CCE = kotlin_kotlin.$_$.b8;
+  var ClosedRange = kotlin_kotlin.$_$.d6;
+  var isInterface = kotlin_kotlin.$_$.o5;
+  var contains = kotlin_kotlin.$_$.h6;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.u;
+  var toString = kotlin_kotlin.$_$.a6;
+  var IllegalArgumentException_init_$Init$ = kotlin_kotlin.$_$.s;
+  var captureStack = kotlin_kotlin.$_$.t4;
+  var IllegalArgumentException_init_$Init$_0 = kotlin_kotlin.$_$.t;
+  var IllegalArgumentException_init_$Init$_1 = kotlin_kotlin.$_$.q;
+  var IllegalArgumentException_init_$Init$_2 = kotlin_kotlin.$_$.v;
+  var IllegalArgumentException = kotlin_kotlin.$_$.x7;
+  var RuntimeException_init_$Init$ = kotlin_kotlin.$_$.b1;
+  var RuntimeException_init_$Init$_0 = kotlin_kotlin.$_$.z;
+  var RuntimeException = kotlin_kotlin.$_$.a8;
+  var Enum = kotlin_kotlin.$_$.v7;
+  var initMetadataForInterface = kotlin_kotlin.$_$.i5;
+  var toString_0 = kotlin_kotlin.$_$.j1;
+  var hashCode = kotlin_kotlin.$_$.f5;
+  var getBooleanHashCode = kotlin_kotlin.$_$.b5;
+  var initMetadataForObject = kotlin_kotlin.$_$.k5;
+  var KProperty0 = kotlin_kotlin.$_$.k6;
+  var getPropertyCallableRef = kotlin_kotlin.$_$.d5;
+  var KMutableProperty1 = kotlin_kotlin.$_$.j6;
+  var lazy = kotlin_kotlin.$_$.o8;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.f;
+  var equals = kotlin_kotlin.$_$.a5;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.w;
+  var toString_1 = kotlin_kotlin.$_$.r8;
+  var getStringHashCode = kotlin_kotlin.$_$.e5;
+  var charSequenceLength = kotlin_kotlin.$_$.w4;
+  var charSequenceGet = kotlin_kotlin.$_$.v4;
+  var listOf = kotlin_kotlin.$_$.k3;
+  var get_lastIndex = kotlin_kotlin.$_$.b7;
+  var emptyList = kotlin_kotlin.$_$.c3;
+  var joinToString = kotlin_kotlin.$_$.i3;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.u2;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.e;
+  var single = kotlin_kotlin.$_$.x3;
+  var charSequenceSubSequence = kotlin_kotlin.$_$.x4;
+  var mutableListOf = kotlin_kotlin.$_$.s3;
+  var removeLastOrNull = kotlin_kotlin.$_$.u3;
+  var sortWith = kotlin_kotlin.$_$.z3;
+  var FunctionAdapter = kotlin_kotlin.$_$.s4;
+  var Comparator = kotlin_kotlin.$_$.u7;
+  var compareValues = kotlin_kotlin.$_$.m4;
+  var Exception = kotlin_kotlin.$_$.w7;
+  var Exception_init_$Init$ = kotlin_kotlin.$_$.p;
+  var StringBuilder_init_$Create$_0 = kotlin_kotlin.$_$.m;
+  var joinTo = kotlin_kotlin.$_$.j3;
+  var plus = kotlin_kotlin.$_$.t3;
+  var toMutableList = kotlin_kotlin.$_$.j4;
+  var addAll = kotlin_kotlin.$_$.q2;
+  var Collection = kotlin_kotlin.$_$.o2;
+  var firstOrNull = kotlin_kotlin.$_$.g3;
+  var drop = kotlin_kotlin.$_$.a3;
+  var listOf_0 = kotlin_kotlin.$_$.l3;
+  var repeat = kotlin_kotlin.$_$.d7;
+  var checkCountOverflow = kotlin_kotlin.$_$.t2;
+  var Char__minus_impl_a2frrh = kotlin_kotlin.$_$.g1;
+  var enumEntries = kotlin_kotlin.$_$.p4;
+  var Comparable = kotlin_kotlin.$_$.t7;
+  var IllegalArgumentException_init_$Create$_0 = kotlin_kotlin.$_$.r;
+  var numberToInt = kotlin_kotlin.$_$.v5;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(DateTimePeriod, 'DateTimePeriod');
+  initMetadataForClass(DatePeriod, 'DatePeriod', DatePeriod_init_$Create$, DateTimePeriod);
+  initMetadataForCompanion(Companion_0);
+  initMetadataForClass(DateTimeFormatException, 'DateTimeFormatException', DateTimeFormatException_init_$Create$, IllegalArgumentException);
+  initMetadataForClass(DateTimeArithmeticException, 'DateTimeArithmeticException', DateTimeArithmeticException_init_$Create$, RuntimeException);
+  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.ug(padding);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.ug.call(this, padding);
+    }
+    return tmp;
+  }
+  function monthNumber$default(padding, $super) {
+    padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+    var tmp;
+    if ($super === VOID) {
+      this.wg(padding);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.wg.call(this, padding);
+    }
+    return tmp;
+  }
+  function dayOfMonth$default(padding, $super) {
+    padding = padding === VOID ? Padding_ZERO_getInstance() : padding;
+    var tmp;
+    if ($super === VOID) {
+      this.yg(padding);
+      tmp = Unit_instance;
+    } else {
+      tmp = $super.yg.call(this, padding);
+    }
+    return tmp;
+  }
+  initMetadataForInterface(WithDate, 'WithDate');
+  function chars(value) {
+    return this.bh().dh(new ConstantFormatStructure(value));
+  }
+  function build() {
+    return new CachedFormatStructure(this.bh().eh().fh_1);
+  }
+  initMetadataForInterface(AbstractDateTimeFormatBuilder, 'AbstractDateTimeFormatBuilder');
+  initMetadataForClass(IncompleteLocalDate, 'IncompleteLocalDate', IncompleteLocalDate);
+  initMetadataForCompanion(Companion_1);
+  function year(padding) {
+    return this.yh(new BasicFormatStructure(new YearDirective(padding)));
+  }
+  function monthNumber(padding) {
+    return this.yh(new BasicFormatStructure(new MonthDirective(padding)));
+  }
+  function dayOfMonth(padding) {
+    return this.yh(new BasicFormatStructure(new DayDirective(padding)));
+  }
+  initMetadataForInterface(AbstractWithDateBuilder, 'AbstractWithDateBuilder', VOID, VOID, [WithDate]);
+  initMetadataForClass(Builder, 'Builder', VOID, VOID, [AbstractDateTimeFormatBuilder, AbstractWithDateBuilder]);
+  initMetadataForClass(LocalDateFormat, 'LocalDateFormat', VOID, AbstractDateTimeFormat);
+  initMetadataForClass(SignedIntFieldFormatDirective, 'SignedIntFieldFormatDirective');
+  initMetadataForClass(YearDirective, 'YearDirective', VOID, SignedIntFieldFormatDirective);
+  initMetadataForClass(UnsignedIntFieldFormatDirective, 'UnsignedIntFieldFormatDirective');
+  initMetadataForClass(MonthDirective, 'MonthDirective', VOID, UnsignedIntFieldFormatDirective);
+  initMetadataForClass(DayDirective, 'DayDirective', VOID, UnsignedIntFieldFormatDirective);
+  initMetadataForObject(DateFields, 'DateFields');
+  initMetadataForClass(AppendableFormatStructure, 'AppendableFormatStructure', AppendableFormatStructure);
+  initMetadataForClass(AbstractFieldSpec, 'AbstractFieldSpec');
+  initMetadataForClass(GenericFieldSpec, 'GenericFieldSpec', VOID, AbstractFieldSpec);
+  function getterNotNull(container) {
+    var tmp0_elvis_lhs = this.xj(container);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      throw IllegalStateException_init_$Create$('Field ' + this.i2() + ' 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]);
+  initMetadataForClass(SpacePaddedFormatter, 'SpacePaddedFormatter');
+  initMetadataForClass(ConcatenatedFormatter, 'ConcatenatedFormatter');
+  initMetadataForClass(SignedIntFormatterStructure, 'SignedIntFormatterStructure');
+  initMetadataForClass(UnsignedIntFormatterStructure, 'UnsignedIntFormatterStructure');
+  initMetadataForClass(ConstantStringFormatterStructure, 'ConstantStringFormatterStructure');
+  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_2);
+  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');
+  initMetadataForClass(DayOfWeek_0, 'DayOfWeek', VOID, Enum);
+  initMetadataForClass(Instant, 'Instant', VOID, VOID, [Comparable]);
+  initMetadataForCompanion(Companion_3);
+  initMetadataForObject(Formats, 'Formats');
+  initMetadataForClass(LocalDate_0, 'LocalDate', VOID, VOID, [Comparable]);
+  initMetadataForCompanion(Companion_4);
+  initMetadataForClass(LocalDateTime_0, 'LocalDateTime', VOID, VOID, [Comparable]);
+  initMetadataForCompanion(Companion_5);
+  initMetadataForClass(TimeZone, 'TimeZone');
+  initMetadataForCompanion(Companion_6);
+  initMetadataForClass(FixedOffsetTimeZone, 'FixedOffsetTimeZone', VOID, TimeZone);
+  initMetadataForCompanion(Companion_7);
+  initMetadataForClass(UtcOffset, 'UtcOffset');
+  //endregion
+  function DatePeriod_init_$Init$(years, months, days, $this) {
+    years = years === VOID ? 0 : years;
+    months = months === VOID ? 0 : months;
+    days = days === VOID ? 0 : days;
+    DatePeriod.call($this, totalMonths(years, months), days);
+    return $this;
+  }
+  function DatePeriod_init_$Create$(years, months, days) {
+    return DatePeriod_init_$Init$(years, months, days, objectCreate(protoOf(DatePeriod)));
+  }
+  function Companion() {
+  }
+  var Companion_instance;
+  function Companion_getInstance() {
+    return Companion_instance;
+  }
+  function DatePeriod(totalMonths, days) {
+    DateTimePeriod.call(this);
+    this.zf_1 = totalMonths;
+    this.ag_1 = days;
+  }
+  protoOf(DatePeriod).bg = function () {
+    return this.zf_1;
+  };
+  protoOf(DatePeriod).cg = function () {
+    return this.ag_1;
+  };
+  protoOf(DatePeriod).dg = function () {
+    return 0;
+  };
+  protoOf(DatePeriod).eg = function () {
+    return 0;
+  };
+  protoOf(DatePeriod).fg = function () {
+    return 0;
+  };
+  protoOf(DatePeriod).gg = function () {
+    return 0;
+  };
+  protoOf(DatePeriod).hg = function () {
+    return new Long(0, 0);
+  };
+  function allNonpositive($this) {
+    return $this.bg() <= 0 && $this.cg() <= 0 && $this.hg().a1(new Long(0, 0)) <= 0 && (!(($this.bg() | $this.cg()) === 0) || !$this.hg().equals(new Long(0, 0)));
+  }
+  function Companion_0() {
+  }
+  var Companion_instance_0;
+  function Companion_getInstance_0() {
+    return Companion_instance_0;
+  }
+  function DateTimePeriod() {
+  }
+  protoOf(DateTimePeriod).ig = function () {
+    return this.bg() / 12 | 0;
+  };
+  protoOf(DateTimePeriod).jg = function () {
+    return this.bg() % 12 | 0;
+  };
+  protoOf(DateTimePeriod).dg = function () {
+    return this.hg().s2(new Long(817405952, 838)).z();
+  };
+  protoOf(DateTimePeriod).eg = function () {
+    return this.hg().t2(new Long(817405952, 838)).s2(new Long(-129542144, 13)).z();
+  };
+  protoOf(DateTimePeriod).fg = function () {
+    // Inline function 'kotlin.Long.div' call
+    var this_0 = this.hg().t2(new Long(-129542144, 13));
+    var other = 1000000000;
+    return this_0.s2(toLong(other)).z();
+  };
+  protoOf(DateTimePeriod).gg = function () {
+    // Inline function 'kotlin.Long.rem' call
+    var this_0 = this.hg();
+    var other = 1000000000;
+    return this_0.t2(toLong(other)).z();
+  };
+  protoOf(DateTimePeriod).toString = function () {
+    // Inline function 'kotlin.text.buildString' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.apply' call
+    var this_0 = StringBuilder_init_$Create$();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.DateTimePeriod.toString.<anonymous>' call
+    var tmp;
+    if (allNonpositive(this)) {
+      this_0.i7(_Char___init__impl__6a9atx(45));
+      tmp = -1;
+    } else {
+      tmp = 1;
+    }
+    var sign = tmp;
+    this_0.i7(_Char___init__impl__6a9atx(80));
+    if (!(this.ig() === 0)) {
+      this_0.ga(imul(this.ig(), sign)).i7(_Char___init__impl__6a9atx(89));
+    }
+    if (!(this.jg() === 0)) {
+      this_0.ga(imul(this.jg(), sign)).i7(_Char___init__impl__6a9atx(77));
+    }
+    if (!(this.cg() === 0)) {
+      this_0.ga(imul(this.cg(), sign)).i7(_Char___init__impl__6a9atx(68));
+    }
+    var t = 'T';
+    if (!(this.dg() === 0)) {
+      // Inline function 'kotlin.also' call
+      this_0.h7(t).ga(imul(this.dg(), sign)).i7(_Char___init__impl__6a9atx(72));
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlinx.datetime.DateTimePeriod.toString.<anonymous>.<anonymous>' call
+      t = '';
+    }
+    if (!(this.eg() === 0)) {
+      // Inline function 'kotlin.also' call
+      this_0.h7(t).ga(imul(this.eg(), sign)).i7(_Char___init__impl__6a9atx(77));
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlinx.datetime.DateTimePeriod.toString.<anonymous>.<anonymous>' call
+      t = '';
+    }
+    if (!((this.fg() | this.gg()) === 0)) {
+      this_0.h7(t);
+      this_0.g7(!(this.fg() === 0) ? imul(this.fg(), sign) : imul(this.gg(), sign) < 0 ? '-0' : '0');
+      if (!(this.gg() === 0)) {
+        var tmp_0 = this_0.i7(_Char___init__impl__6a9atx(46));
+        // Inline function 'kotlin.math.absoluteValue' call
+        var this_1 = this.gg();
+        var tmp$ret$2 = abs(this_1);
+        tmp_0.h7(padStart(tmp$ret$2.toString(), 9, _Char___init__impl__6a9atx(48)));
+      }
+      this_0.i7(_Char___init__impl__6a9atx(83));
+    }
+    if (this_0.a() === 1) {
+      this_0.h7('0D');
+    }
+    return this_0.toString();
+  };
+  protoOf(DateTimePeriod).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof DateTimePeriod))
+      return false;
+    if (!(this.bg() === other.bg()))
+      return false;
+    if (!(this.cg() === other.cg()))
+      return false;
+    if (!this.hg().equals(other.hg()))
+      return false;
+    return true;
+  };
+  protoOf(DateTimePeriod).hashCode = function () {
+    var result = this.bg();
+    result = imul(31, result) + this.cg() | 0;
+    result = imul(31, result) + this.hg().hashCode() | 0;
+    return result;
+  };
+  function totalMonths(years, months) {
+    // Inline function 'kotlin.Long.times' call
+    var totalMonths = toLong(years).r2(toLong(12)).p2(toLong(months));
+    var tmp;
+    // Inline function 'kotlin.ranges.contains' call
+    var this_0 = numberRangeToNumber(-2147483648, 2147483647);
+    if (contains(isInterface(this_0, ClosedRange) ? this_0 : THROW_CCE(), totalMonths)) {
+      tmp = totalMonths.z();
+    } else {
+      throw IllegalArgumentException_init_$Create$('The total number of months in ' + years + ' years and ' + months + ' months overflows an Int');
+    }
+    return tmp;
+  }
+  function get_isoDayNumber(_this__u8e3s4) {
+    return _this__u8e3s4.h2_1 + 1 | 0;
+  }
+  function DayOfWeek(isoDayNumber) {
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(1 <= isoDayNumber ? isoDayNumber <= 7 : false)) {
+      // Inline function 'kotlinx.datetime.DayOfWeek.<anonymous>' call
+      var message = 'Expected ISO day-of-week number in 1..7, got ' + isoDayNumber;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    return get_entries().n(isoDayNumber - 1 | 0);
+  }
+  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(cause, $this) {
+    IllegalArgumentException_init_$Init$_1(cause, $this);
+    DateTimeFormatException.call($this);
+    return $this;
+  }
+  function DateTimeFormatException_init_$Create$_1(cause) {
+    var tmp = DateTimeFormatException_init_$Init$_1(cause, objectCreate(protoOf(DateTimeFormatException)));
+    captureStack(tmp, DateTimeFormatException_init_$Create$_1);
+    return tmp;
+  }
+  function DateTimeFormatException_init_$Init$_2(message, cause, $this) {
+    IllegalArgumentException_init_$Init$_2(message, cause, $this);
+    DateTimeFormatException.call($this);
+    return $this;
+  }
+  function DateTimeFormatException_init_$Create$_2(message, cause) {
+    var tmp = DateTimeFormatException_init_$Init$_2(message, cause, objectCreate(protoOf(DateTimeFormatException)));
+    captureStack(tmp, DateTimeFormatException_init_$Create$_2);
+    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(cause, $this) {
+    RuntimeException_init_$Init$_0(cause, $this);
+    DateTimeArithmeticException.call($this);
+    return $this;
+  }
+  function DateTimeArithmeticException_init_$Create$_0(cause) {
+    var tmp = DateTimeArithmeticException_init_$Init$_0(cause, objectCreate(protoOf(DateTimeArithmeticException)));
+    captureStack(tmp, DateTimeArithmeticException_init_$Create$_0);
+    return tmp;
+  }
+  function DateTimeArithmeticException() {
+    captureStack(this, DateTimeArithmeticException);
+  }
+  function getIsoDateFormat() {
+    return Formats_getInstance().lg();
+  }
+  function asTimeZone(_this__u8e3s4) {
+    return FixedOffsetTimeZone_init_$Create$(_this__u8e3s4);
+  }
+  function AbstractDateTimeFormat() {
+  }
+  protoOf(AbstractDateTimeFormat).pg = function (input) {
+    var tmp;
+    try {
+      tmp = Parser__match$default_impl_x2xlti(_Parser___init__impl__gdyfby(this.mg().tg()), input, this.og());
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof ParseException) {
+        var e = $p;
+        throw DateTimeFormatException_init_$Create$_2("Failed to parse value from '" + toString(input) + "'", e);
+      } else {
+        throw $p;
+      }
+    }
+    var matched = tmp;
+    try {
+      return this.ng(matched);
+    } catch ($p) {
+      if ($p instanceof IllegalArgumentException) {
+        var e_0 = $p;
+        var message = e_0.message;
+        throw DateTimeFormatException_init_$Create$_2(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 WithDate() {
+  }
+  function char(_this__u8e3s4, value) {
+    return _this__u8e3s4.ah(toString_0(value));
+  }
+  function AbstractDateTimeFormatBuilder() {
+  }
+  function get_ISO_DATE() {
+    _init_properties_LocalDateFormat_kt__k1uk9u();
+    // Inline function 'kotlin.getValue' call
+    var this_0 = ISO_DATE$delegate;
+    ISO_DATE$factory();
+    return this_0.b2();
+  }
+  var ISO_DATE$delegate;
+  function get_ISO_DATE_BASIC() {
+    _init_properties_LocalDateFormat_kt__k1uk9u();
+    // Inline function 'kotlin.getValue' call
+    var this_0 = ISO_DATE_BASIC$delegate;
+    ISO_DATE_BASIC$factory();
+    return this_0.b2();
+  }
+  var ISO_DATE_BASIC$delegate;
+  function get_emptyIncompleteLocalDate() {
+    _init_properties_LocalDateFormat_kt__k1uk9u();
+    return emptyIncompleteLocalDate;
+  }
+  var emptyIncompleteLocalDate;
+  function IncompleteLocalDate(year, monthNumber, dayOfMonth, isoDayOfWeek) {
+    year = year === VOID ? null : year;
+    monthNumber = monthNumber === VOID ? null : monthNumber;
+    dayOfMonth = dayOfMonth === VOID ? null : dayOfMonth;
+    isoDayOfWeek = isoDayOfWeek === VOID ? null : isoDayOfWeek;
+    this.gh_1 = year;
+    this.hh_1 = monthNumber;
+    this.ih_1 = dayOfMonth;
+    this.jh_1 = isoDayOfWeek;
+  }
+  protoOf(IncompleteLocalDate).kh = function (_set____db54di) {
+    this.gh_1 = _set____db54di;
+  };
+  protoOf(IncompleteLocalDate).lh = function () {
+    return this.gh_1;
+  };
+  protoOf(IncompleteLocalDate).mh = function (_set____db54di) {
+    this.hh_1 = _set____db54di;
+  };
+  protoOf(IncompleteLocalDate).nh = function () {
+    return this.hh_1;
+  };
+  protoOf(IncompleteLocalDate).oh = function (_set____db54di) {
+    this.ih_1 = _set____db54di;
+  };
+  protoOf(IncompleteLocalDate).ph = function () {
+    return this.ih_1;
+  };
+  protoOf(IncompleteLocalDate).qh = function (_set____db54di) {
+    this.jh_1 = _set____db54di;
+  };
+  protoOf(IncompleteLocalDate).rh = function () {
+    return this.jh_1;
+  };
+  protoOf(IncompleteLocalDate).sh = function () {
+    var date = LocalDate_init_$Create$(requireParsedField(this.gh_1, 'year'), requireParsedField(this.hh_1, 'monthNumber'), requireParsedField(this.ih_1, 'dayOfMonth'));
+    var tmp0_safe_receiver = this.jh_1;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.contracts.contract' call
+      if (!(tmp0_safe_receiver === get_isoDayNumber(date.uh()))) {
+        throw DateTimeFormatException_init_$Create$_0('Can not create a LocalDate from the given input: ' + ('the day of week is ' + DayOfWeek(tmp0_safe_receiver).toString() + ' but the date is ' + date.toString() + ', which is a ' + date.uh().toString()));
+      }
+    }
+    return date;
+  };
+  protoOf(IncompleteLocalDate).vh = function () {
+    return new IncompleteLocalDate(this.gh_1, this.hh_1, this.ih_1, this.jh_1);
+  };
+  protoOf(IncompleteLocalDate).equals = function (other) {
+    var tmp;
+    var tmp_0;
+    var tmp_1;
+    var tmp_2;
+    if (other instanceof IncompleteLocalDate) {
+      tmp_2 = this.gh_1 == other.gh_1;
+    } else {
+      tmp_2 = false;
+    }
+    if (tmp_2) {
+      tmp_1 = this.hh_1 == other.hh_1;
+    } else {
+      tmp_1 = false;
+    }
+    if (tmp_1) {
+      tmp_0 = this.ih_1 == other.ih_1;
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = this.jh_1 == other.jh_1;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(IncompleteLocalDate).hashCode = function () {
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver = this.gh_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.hh_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_0 = tmp + imul(tmp$ret$1, 31) | 0;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver_1 = this.ih_1;
+    var tmp1_elvis_lhs_1 = tmp0_safe_receiver_1 == null ? null : hashCode(tmp0_safe_receiver_1);
+    var tmp$ret$2 = tmp1_elvis_lhs_1 == null ? 0 : tmp1_elvis_lhs_1;
+    var tmp_1 = tmp_0 + imul(tmp$ret$2, 31) | 0;
+    // Inline function 'kotlin.hashCode' call
+    var tmp0_safe_receiver_2 = this.jh_1;
+    var tmp1_elvis_lhs_2 = tmp0_safe_receiver_2 == null ? null : hashCode(tmp0_safe_receiver_2);
+    var tmp$ret$3 = tmp1_elvis_lhs_2 == null ? 0 : tmp1_elvis_lhs_2;
+    return tmp_1 + imul(tmp$ret$3, 31) | 0;
+  };
+  protoOf(IncompleteLocalDate).toString = function () {
+    var tmp0_elvis_lhs = this.gh_1;
+    var tmp = toString(tmp0_elvis_lhs == null ? '??' : tmp0_elvis_lhs);
+    var tmp1_elvis_lhs = this.hh_1;
+    var tmp_0 = toString(tmp1_elvis_lhs == null ? '??' : tmp1_elvis_lhs);
+    var tmp2_elvis_lhs = this.ih_1;
+    var tmp_1 = toString(tmp2_elvis_lhs == null ? '??' : tmp2_elvis_lhs);
+    var tmp3_elvis_lhs = this.jh_1;
+    return tmp + '-' + tmp_0 + '-' + tmp_1 + ' (day of week is ' + toString(tmp3_elvis_lhs == null ? '??' : tmp3_elvis_lhs) + ')';
+  };
+  function Companion_1() {
+  }
+  protoOf(Companion_1).wh = function (block) {
+    var builder = new Builder(new AppendableFormatStructure());
+    block(builder);
+    return new LocalDateFormat(builder.eh());
+  };
+  var Companion_instance_1;
+  function Companion_getInstance_1() {
+    return Companion_instance_1;
+  }
+  function Builder(actualBuilder) {
+    this.xh_1 = actualBuilder;
+  }
+  protoOf(Builder).bh = function () {
+    return this.xh_1;
+  };
+  protoOf(Builder).yh = function (structure) {
+    return this.xh_1.dh(structure);
+  };
+  function LocalDateFormat(actualFormat) {
+    AbstractDateTimeFormat.call(this);
+    this.zh_1 = actualFormat;
+  }
+  protoOf(LocalDateFormat).mg = function () {
+    return this.zh_1;
+  };
+  protoOf(LocalDateFormat).ai = function (intermediate) {
+    return intermediate.sh();
+  };
+  protoOf(LocalDateFormat).ng = function (intermediate) {
+    return this.ai(intermediate instanceof IncompleteLocalDate ? intermediate : THROW_CCE());
+  };
+  protoOf(LocalDateFormat).og = function () {
+    return get_emptyIncompleteLocalDate();
+  };
+  function requireParsedField(field, name) {
+    _init_properties_LocalDateFormat_kt__k1uk9u();
+    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 AbstractWithDateBuilder() {
+  }
+  function YearDirective(padding, isYearOfEra) {
+    isYearOfEra = isYearOfEra === VOID ? false : isYearOfEra;
+    var tmp = DateFields_getInstance().bi_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.ki_1 = padding;
+    this.li_1 = isYearOfEra;
+  }
+  protoOf(YearDirective).equals = function (other) {
+    var tmp;
+    var tmp_0;
+    if (other instanceof YearDirective) {
+      tmp_0 = this.ki_1.equals(other.ki_1);
+    } else {
+      tmp_0 = false;
+    }
+    if (tmp_0) {
+      tmp = this.li_1 === other.li_1;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(YearDirective).hashCode = function () {
+    return imul(this.ki_1.hashCode(), 31) + getBooleanHashCode(this.li_1) | 0;
+  };
+  function MonthDirective(padding) {
+    var tmp = DateFields_getInstance().ci_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.wi_1 = padding;
+  }
+  protoOf(MonthDirective).equals = function (other) {
+    var tmp;
+    if (other instanceof MonthDirective) {
+      tmp = this.wi_1.equals(other.wi_1);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(MonthDirective).hashCode = function () {
+    return this.wi_1.hashCode();
+  };
+  function DayDirective(padding) {
+    var tmp = DateFields_getInstance().di_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.fj_1 = padding;
+  }
+  protoOf(DayDirective).equals = function (other) {
+    var tmp;
+    if (other instanceof DayDirective) {
+      tmp = this.fj_1.equals(other.fj_1);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(DayDirective).hashCode = function () {
+    return this.fj_1.hashCode();
+  };
+  function DateFields() {
+    DateFields_instance = this;
+    this.bi_1 = new GenericFieldSpec(new PropertyAccessor(year$factory()));
+    this.ci_1 = new UnsignedFieldSpec(new PropertyAccessor(monthNumber$factory()), 1, 12);
+    this.di_1 = new UnsignedFieldSpec(new PropertyAccessor(dayOfMonth$factory()), 1, 31);
+    this.ei_1 = new UnsignedFieldSpec(new PropertyAccessor(isoDayOfWeek$factory()), 1, 7);
+  }
+  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_1;
+    return tmp.wh(ISO_DATE$delegate$lambda$lambda);
+  }
+  function ISO_DATE$delegate$lambda$lambda($this$build) {
+    _init_properties_LocalDateFormat_kt__k1uk9u();
+    $this$build.vg();
+    char($this$build, _Char___init__impl__6a9atx(45));
+    $this$build.xg();
+    char($this$build, _Char___init__impl__6a9atx(45));
+    $this$build.zg();
+    return Unit_instance;
+  }
+  function ISO_DATE_BASIC$delegate$lambda() {
+    _init_properties_LocalDateFormat_kt__k1uk9u();
+    var tmp = Companion_instance_1;
+    return tmp.wh(ISO_DATE_BASIC$delegate$lambda$lambda);
+  }
+  function ISO_DATE_BASIC$delegate$lambda$lambda($this$build) {
+    _init_properties_LocalDateFormat_kt__k1uk9u();
+    $this$build.vg();
+    $this$build.xg();
+    $this$build.zg();
+    return Unit_instance;
+  }
+  function ISO_DATE$factory() {
+    return getPropertyCallableRef('ISO_DATE', 0, KProperty0, function () {
+      return get_ISO_DATE();
+    }, null);
+  }
+  function ISO_DATE_BASIC$factory() {
+    return getPropertyCallableRef('ISO_DATE_BASIC', 0, KProperty0, function () {
+      return get_ISO_DATE_BASIC();
+    }, null);
+  }
+  function year$factory() {
+    return getPropertyCallableRef('year', 1, KMutableProperty1, function (receiver) {
+      return receiver.lh();
+    }, function (receiver, value) {
+      return receiver.kh(value);
+    });
+  }
+  function monthNumber$factory() {
+    return getPropertyCallableRef('monthNumber', 1, KMutableProperty1, function (receiver) {
+      return receiver.nh();
+    }, function (receiver, value) {
+      return receiver.mh(value);
+    });
+  }
+  function dayOfMonth$factory() {
+    return getPropertyCallableRef('dayOfMonth', 1, KMutableProperty1, function (receiver) {
+      return receiver.ph();
+    }, function (receiver, value) {
+      return receiver.oh(value);
+    });
+  }
+  function isoDayOfWeek$factory() {
+    return getPropertyCallableRef('isoDayOfWeek', 1, KMutableProperty1, function (receiver) {
+      return receiver.rh();
+    }, function (receiver, value) {
+      return receiver.qh(value);
+    });
+  }
+  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 AppendableFormatStructure() {
+    var tmp = this;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    tmp.ch_1 = ArrayList_init_$Create$();
+  }
+  protoOf(AppendableFormatStructure).eh = function () {
+    return new ConcatenatedFormatStructure(this.ch_1);
+  };
+  protoOf(AppendableFormatStructure).dh = function (format) {
+    if (isInterface(format, NonConcatenatedFormatStructure)) {
+      this.ch_1.e(format);
+    } else {
+      if (format instanceof ConcatenatedFormatStructure) {
+        // Inline function 'kotlin.collections.forEach' call
+        var tmp0_iterator = format.fh_1.j();
+        while (tmp0_iterator.k()) {
+          var element = tmp0_iterator.l();
+          // Inline function 'kotlinx.datetime.internal.format.AppendableFormatStructure.add.<anonymous>' call
+          this.ch_1.e(element);
+        }
+      }
+    }
+  };
+  function Accessor$getterNotNull$ref($boundThis) {
+    var l = function (p0) {
+      return $boundThis.gj(p0);
+    };
+    l.callableName = 'getterNotNull';
+    return l;
+  }
+  function SignedIntFieldFormatDirective(field, minDigits, maxDigits, spacePadding, outputPlusOnExceededWidth) {
+    this.mi_1 = field;
+    this.ni_1 = minDigits;
+    this.oi_1 = maxDigits;
+    this.pi_1 = spacePadding;
+    this.qi_1 = outputPlusOnExceededWidth;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.ni_1 == null || this.ni_1 >= 0)) {
+      // Inline function 'kotlinx.datetime.internal.format.SignedIntFieldFormatDirective.<anonymous>' call
+      var message = 'The minimum number of digits (' + this.ni_1 + ') is negative';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.oi_1 == null || this.ni_1 == null || this.oi_1 >= this.ni_1)) {
+      // Inline function 'kotlinx.datetime.internal.format.SignedIntFieldFormatDirective.<anonymous>' call
+      var message_0 = 'The maximum number of digits (' + this.oi_1 + ') is less than the minimum number of digits (' + this.ni_1 + ')';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+  }
+  protoOf(SignedIntFieldFormatDirective).ri = function () {
+    var tmp = Accessor$getterNotNull$ref(this.mi_1.hj());
+    var tmp0_elvis_lhs = this.ni_1;
+    var formatter = new SignedIntFormatterStructure(tmp, tmp0_elvis_lhs == null ? 0 : tmp0_elvis_lhs, this.qi_1);
+    return !(this.pi_1 == null) ? new SpacePaddedFormatter(formatter, this.pi_1) : formatter;
+  };
+  protoOf(SignedIntFieldFormatDirective).tg = function () {
+    return SignedIntParser(this.ni_1, this.oi_1, this.pi_1, this.mi_1.hj(), this.mi_1.i2(), this.qi_1);
+  };
+  function Accessor$getterNotNull$ref_0($boundThis) {
+    var l = function (p0) {
+      return $boundThis.gj(p0);
+    };
+    l.callableName = 'getterNotNull';
+    return l;
+  }
+  function UnsignedIntFieldFormatDirective(field, minDigits, spacePadding) {
+    this.xi_1 = field;
+    this.yi_1 = minDigits;
+    this.zi_1 = spacePadding;
+    this.aj_1 = this.xi_1.oj_1;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.yi_1 >= 0)) {
+      // Inline function 'kotlinx.datetime.internal.format.UnsignedIntFieldFormatDirective.<anonymous>' call
+      var message = 'The minimum number of digits (' + this.yi_1 + ') is negative';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.aj_1 >= this.yi_1)) {
+      // Inline function 'kotlinx.datetime.internal.format.UnsignedIntFieldFormatDirective.<anonymous>' call
+      var message_0 = 'The maximum number of digits (' + this.aj_1 + ') is less than the minimum number of digits (' + this.yi_1 + ')';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    if (!(this.zi_1 == null)) {
+      // Inline function 'kotlin.require' call
+      // Inline function 'kotlin.contracts.contract' call
+      if (!(this.zi_1 > this.yi_1)) {
+        // Inline function 'kotlinx.datetime.internal.format.UnsignedIntFieldFormatDirective.<anonymous>' call
+        var message_1 = 'The space padding (' + this.zi_1 + ') should be more than the minimum number of digits (' + this.yi_1 + ')';
+        throw IllegalArgumentException_init_$Create$(toString(message_1));
+      }
+    }
+  }
+  protoOf(UnsignedIntFieldFormatDirective).ri = function () {
+    var formatter = new UnsignedIntFormatterStructure(Accessor$getterNotNull$ref_0(this.xi_1.ij_1), this.yi_1);
+    return !(this.zi_1 == null) ? new SpacePaddedFormatter(formatter, this.zi_1) : formatter;
+  };
+  protoOf(UnsignedIntFieldFormatDirective).tg = function () {
+    return spaceAndZeroPaddedUnsignedInt(this.yi_1, this.aj_1, this.zi_1, this.xi_1.ij_1, this.xi_1.lj_1);
+  };
+  function GenericFieldSpec(accessor, name, defaultValue, sign) {
+    name = name === VOID ? accessor.i2() : name;
+    defaultValue = defaultValue === VOID ? null : defaultValue;
+    sign = sign === VOID ? null : sign;
+    AbstractFieldSpec.call(this);
+    this.pj_1 = accessor;
+    this.qj_1 = name;
+    this.rj_1 = defaultValue;
+    this.sj_1 = sign;
+  }
+  protoOf(GenericFieldSpec).hj = function () {
+    return this.pj_1;
+  };
+  protoOf(GenericFieldSpec).i2 = function () {
+    return this.qj_1;
+  };
+  protoOf(GenericFieldSpec).tj = function () {
+    return this.rj_1;
+  };
+  function PropertyAccessor(property) {
+    this.uj_1 = property;
+  }
+  protoOf(PropertyAccessor).i2 = function () {
+    return this.uj_1.callableName;
+  };
+  protoOf(PropertyAccessor).vj = function (container, newValue) {
+    var oldValue = this.uj_1.get(container);
+    var tmp;
+    if (oldValue === null) {
+      this.uj_1.set(container, newValue);
+      tmp = null;
+    } else if (equals(oldValue, newValue)) {
+      tmp = null;
+    } else {
+      tmp = oldValue;
+    }
+    return tmp;
+  };
+  protoOf(PropertyAccessor).wj = function (container, newValue) {
+    var tmp = (container == null ? true : !(container == null)) ? container : THROW_CCE();
+    return this.vj(tmp, (newValue == null ? true : !(newValue == null)) ? newValue : THROW_CCE());
+  };
+  protoOf(PropertyAccessor).xj = function (container) {
+    return this.uj_1.get(container);
+  };
+  function UnsignedFieldSpec(accessor, minValue, maxValue, name, defaultValue, sign) {
+    name = name === VOID ? accessor.i2() : name;
+    defaultValue = defaultValue === VOID ? null : defaultValue;
+    sign = sign === VOID ? null : sign;
+    AbstractFieldSpec.call(this);
+    this.ij_1 = accessor;
+    this.jj_1 = minValue;
+    this.kj_1 = maxValue;
+    this.lj_1 = name;
+    this.mj_1 = defaultValue;
+    this.nj_1 = sign;
+    var tmp = this;
+    var tmp_0;
+    if (this.kj_1 < 10) {
+      tmp_0 = 1;
+    } else if (this.kj_1 < 100) {
+      tmp_0 = 2;
+    } else if (this.kj_1 < 1000) {
+      tmp_0 = 3;
+    } else {
+      throw IllegalArgumentException_init_$Create$('Max value ' + this.kj_1 + ' is too large');
+    }
+    tmp.oj_1 = tmp_0;
+  }
+  protoOf(UnsignedFieldSpec).hj = function () {
+    return this.ij_1;
+  };
+  protoOf(UnsignedFieldSpec).i2 = function () {
+    return this.lj_1;
+  };
+  protoOf(UnsignedFieldSpec).tj = function () {
+    return this.mj_1;
+  };
+  function Accessor() {
+  }
+  function AbstractFieldSpec() {
+  }
+  protoOf(AbstractFieldSpec).toString = function () {
+    return 'The field ' + this.i2() + ' (default value is ' + toString_1(this.tj()) + ')';
+  };
+  function CachedFormatStructure(formats) {
+    ConcatenatedFormatStructure.call(this, formats);
+    this.rg_1 = protoOf(ConcatenatedFormatStructure).ri.call(this);
+    this.sg_1 = protoOf(ConcatenatedFormatStructure).tg.call(this);
+  }
+  protoOf(CachedFormatStructure).ri = function () {
+    return this.rg_1;
+  };
+  protoOf(CachedFormatStructure).tg = function () {
+    return this.sg_1;
+  };
+  function BasicFormatStructure(directive) {
+    this.yj_1 = directive;
+  }
+  protoOf(BasicFormatStructure).toString = function () {
+    return 'BasicFormatStructure(' + toString(this.yj_1) + ')';
+  };
+  protoOf(BasicFormatStructure).equals = function (other) {
+    var tmp;
+    if (other instanceof BasicFormatStructure) {
+      tmp = equals(this.yj_1, other.yj_1);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(BasicFormatStructure).hashCode = function () {
+    return hashCode(this.yj_1);
+  };
+  protoOf(BasicFormatStructure).tg = function () {
+    return this.yj_1.tg();
+  };
+  protoOf(BasicFormatStructure).ri = function () {
+    return this.yj_1.ri();
+  };
+  function ConstantFormatStructure(string) {
+    this.zj_1 = string;
+  }
+  protoOf(ConstantFormatStructure).toString = function () {
+    return 'ConstantFormatStructure(' + this.zj_1 + ')';
+  };
+  protoOf(ConstantFormatStructure).equals = function (other) {
+    var tmp;
+    if (other instanceof ConstantFormatStructure) {
+      tmp = this.zj_1 === other.zj_1;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(ConstantFormatStructure).hashCode = function () {
+    return getStringHashCode(this.zj_1);
+  };
+  protoOf(ConstantFormatStructure).tg = function () {
+    var tmp;
+    // Inline function 'kotlin.text.isEmpty' call
+    var this_0 = this.zj_1;
+    if (charSequenceLength(this_0) === 0) {
+      tmp = emptyList();
+    } else {
+      // Inline function 'kotlin.collections.buildList' call
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlin.collections.buildListInternal' call
+      // Inline function 'kotlin.apply' call
+      var this_1 = ArrayList_init_$Create$();
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>' call
+      var tmp_0;
+      if (isAsciiDigit(charSequenceGet(this.zj_1, 0))) {
+        var tmp$ret$4;
+        $l$block: {
+          // Inline function 'kotlin.text.takeWhile' call
+          var this_2 = this.zj_1;
+          var inductionVariable = 0;
+          var last = this_2.length;
+          if (inductionVariable < last)
+            do {
+              var index = inductionVariable;
+              inductionVariable = inductionVariable + 1 | 0;
+              // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+              var it = charSequenceGet(this_2, index);
+              if (!isAsciiDigit(it)) {
+                // Inline function 'kotlin.text.substring' call
+                // Inline function 'kotlin.js.asDynamic' call
+                tmp$ret$4 = this_2.substring(0, index);
+                break $l$block;
+              }
+            }
+             while (inductionVariable < last);
+          tmp$ret$4 = this_2;
+        }
+        this_1.e(new NumberSpanParserOperation(listOf(new ConstantNumberConsumer(tmp$ret$4))));
+        var tmp$ret$8;
+        $l$block_0: {
+          // Inline function 'kotlin.text.dropWhile' call
+          var this_3 = this.zj_1;
+          var inductionVariable_0 = 0;
+          var last_0 = charSequenceLength(this_3) - 1 | 0;
+          if (inductionVariable_0 <= last_0)
+            do {
+              var index_0 = inductionVariable_0;
+              inductionVariable_0 = inductionVariable_0 + 1 | 0;
+              // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+              var it_0 = charSequenceGet(this_3, index_0);
+              if (!isAsciiDigit(it_0)) {
+                // Inline function 'kotlin.text.substring' call
+                // Inline function 'kotlin.js.asDynamic' call
+                tmp$ret$8 = this_3.substring(index_0);
+                break $l$block_0;
+              }
+            }
+             while (inductionVariable_0 <= last_0);
+          tmp$ret$8 = '';
+        }
+        tmp_0 = tmp$ret$8;
+      } else {
+        tmp_0 = this.zj_1;
+      }
+      var suffix = tmp_0;
+      // Inline function 'kotlin.text.isNotEmpty' call
+      if (charSequenceLength(suffix) > 0) {
+        if (isAsciiDigit(charSequenceGet(suffix, suffix.length - 1 | 0))) {
+          var tmp$ret$13;
+          $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;
+                // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+                var it_1 = charSequenceGet(suffix, index_1);
+                if (!isAsciiDigit(it_1)) {
+                  // Inline function 'kotlin.text.substring' call
+                  var endIndex = index_1 + 1 | 0;
+                  // Inline function 'kotlin.js.asDynamic' call
+                  tmp$ret$13 = suffix.substring(0, endIndex);
+                  break $l$block_1;
+                }
+              }
+               while (0 <= inductionVariable_1);
+            tmp$ret$13 = '';
+          }
+          this_1.e(new PlainStringParserOperation(tmp$ret$13));
+          var tmp$ret$17;
+          $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;
+                // Inline function 'kotlinx.datetime.internal.format.ConstantFormatStructure.parser.<anonymous>.<anonymous>' call
+                var it_2 = charSequenceGet(suffix, index_2);
+                if (!isAsciiDigit(it_2)) {
+                  // Inline function 'kotlin.text.substring' call
+                  var startIndex = index_2 + 1 | 0;
+                  // Inline function 'kotlin.js.asDynamic' call
+                  tmp$ret$17 = suffix.substring(startIndex);
+                  break $l$block_2;
+                }
+              }
+               while (0 <= inductionVariable_2);
+            tmp$ret$17 = suffix;
+          }
+          this_1.e(new NumberSpanParserOperation(listOf(new ConstantNumberConsumer(tmp$ret$17))));
+        } else {
+          this_1.e(new PlainStringParserOperation(suffix));
+        }
+      }
+      tmp = this_1.d5();
+    }
+    return new ParserStructure(tmp, emptyList());
+  };
+  protoOf(ConstantFormatStructure).ri = function () {
+    return new ConstantStringFormatterStructure(this.zj_1);
+  };
+  function ConcatenatedFormatStructure(formats) {
+    this.fh_1 = formats;
+  }
+  protoOf(ConcatenatedFormatStructure).toString = function () {
+    return 'ConcatenatedFormatStructure(' + joinToString(this.fh_1, ', ') + ')';
+  };
+  protoOf(ConcatenatedFormatStructure).equals = function (other) {
+    var tmp;
+    if (other instanceof ConcatenatedFormatStructure) {
+      tmp = equals(this.fh_1, other.fh_1);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(ConcatenatedFormatStructure).hashCode = function () {
+    return hashCode(this.fh_1);
+  };
+  protoOf(ConcatenatedFormatStructure).tg = function () {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = this.fh_1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.j();
+    while (tmp0_iterator.k()) {
+      var item = tmp0_iterator.l();
+      // Inline function 'kotlinx.datetime.internal.format.ConcatenatedFormatStructure.parser.<anonymous>' call
+      var tmp$ret$0 = item.tg();
+      destination.e(tmp$ret$0);
+    }
+    return concat(destination);
+  };
+  protoOf(ConcatenatedFormatStructure).ri = function () {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = this.fh_1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.j();
+    while (tmp0_iterator.k()) {
+      var item = tmp0_iterator.l();
+      // Inline function 'kotlinx.datetime.internal.format.ConcatenatedFormatStructure.formatter.<anonymous>' call
+      var tmp$ret$0 = item.ri();
+      destination.e(tmp$ret$0);
+    }
+    var formatters = destination;
+    var tmp;
+    if (formatters.o() === 1) {
+      tmp = single(formatters);
+    } else {
+      tmp = new ConcatenatedFormatter(formatters);
+    }
+    return tmp;
+  };
+  function NonConcatenatedFormatStructure() {
+  }
+  function SpacePaddedFormatter(formatter, padding) {
+    this.ak_1 = formatter;
+    this.bk_1 = padding;
+  }
+  function ConcatenatedFormatter(formatters) {
+    this.ck_1 = formatters;
+  }
+  function SignedIntFormatterStructure(number, zeroPadding, outputPlusOnExceededWidth) {
+    this.dk_1 = number;
+    this.ek_1 = zeroPadding;
+    this.fk_1 = outputPlusOnExceededWidth;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.ek_1 >= 0)) {
+      // Inline function 'kotlinx.datetime.internal.format.formatter.SignedIntFormatterStructure.<anonymous>' call
+      var message = 'The minimum number of digits (' + this.ek_1 + ') is negative';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.ek_1 <= 9)) {
+      // Inline function 'kotlinx.datetime.internal.format.formatter.SignedIntFormatterStructure.<anonymous>' call
+      var message_0 = 'The minimum number of digits (' + this.ek_1 + ') exceeds the length of an Int';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+  }
+  function UnsignedIntFormatterStructure(number, zeroPadding) {
+    this.gk_1 = number;
+    this.hk_1 = zeroPadding;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.hk_1 >= 0)) {
+      // Inline function 'kotlinx.datetime.internal.format.formatter.UnsignedIntFormatterStructure.<anonymous>' call
+      var message = 'The minimum number of digits (' + this.hk_1 + ') is negative';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.hk_1 <= 9)) {
+      // Inline function 'kotlinx.datetime.internal.format.formatter.UnsignedIntFormatterStructure.<anonymous>' call
+      var message_0 = 'The minimum number of digits (' + this.hk_1 + ') exceeds the length of an Int';
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+  }
+  function ConstantStringFormatterStructure(string) {
+    this.ik_1 = string;
+  }
+  function ConstantNumberConsumer(expected) {
+    NumberConsumer.call(this, expected.length, 'the predefined string ' + expected);
+    this.lk_1 = expected;
+  }
+  protoOf(ConstantNumberConsumer).mk = function (storage, input, start, end) {
+    var tmp;
+    // Inline function 'kotlin.text.substring' call
+    if (toString(charSequenceSubSequence(input, start, end)) === this.lk_1) {
+      tmp = null;
+    } else {
+      tmp = new WrongConstant(this.lk_1);
+    }
+    return tmp;
+  };
+  function NumberConsumer(length, whatThisExpects) {
+    this.nk_1 = length;
+    this.ok_1 = whatThisExpects;
+  }
+  protoOf(NumberConsumer).a = function () {
+    return this.nk_1;
+  };
+  function ExpectedInt() {
+  }
+  protoOf(ExpectedInt).pk = function () {
+    return 'expected an Int value';
+  };
+  var ExpectedInt_instance;
+  function ExpectedInt_getInstance() {
+    return ExpectedInt_instance;
+  }
+  function TooManyDigits(maxDigits) {
+    this.qk_1 = maxDigits;
+  }
+  protoOf(TooManyDigits).pk = function () {
+    return 'expected at most ' + this.qk_1 + ' digits';
+  };
+  function TooFewDigits(minDigits) {
+    this.rk_1 = minDigits;
+  }
+  protoOf(TooFewDigits).pk = function () {
+    return 'expected at least ' + this.rk_1 + ' digits';
+  };
+  function WrongConstant(expected) {
+    this.sk_1 = expected;
+  }
+  protoOf(WrongConstant).pk = function () {
+    return "expected '" + this.sk_1 + "'";
+  };
+  function Conflicting(conflicting) {
+    this.tk_1 = conflicting;
+  }
+  protoOf(Conflicting).pk = function () {
+    return "attempted to overwrite the existing value '" + toString(this.tk_1) + "'";
+  };
+  function setWithoutReassigning(_this__u8e3s4, receiver, value) {
+    var tmp0_elvis_lhs = _this__u8e3s4.wj(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.wk_1 = minLength;
+    this.xk_1 = maxLength;
+    this.yk_1 = setter;
+    this.zk_1 = multiplyByMinus1;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(this.a() == null || numberRangeToNumber(1, 9).ge(this.a()))) {
+      // Inline function 'kotlinx.datetime.internal.format.parser.UnsignedIntConsumer.<anonymous>' call
+      var message = 'Invalid length for field ' + this.ok_1 + ': ' + this.a();
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+  }
+  protoOf(UnsignedIntConsumer).mk = function (storage, input, start, end) {
+    var tmp;
+    if (!(this.xk_1 == null) && (end - start | 0) > this.xk_1) {
+      tmp = new TooManyDigits(this.xk_1);
+    } else if (!(this.wk_1 == null) && (end - start | 0) < this.wk_1) {
+      tmp = new TooFewDigits(this.wk_1);
+    } else {
+      var result = parseAsciiIntOrNull(input, start, end);
+      tmp = result == null ? ExpectedInt_instance : setWithoutReassigning(this.yk_1, storage, this.zk_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.al_1 = position;
+    this.bl_1 = message;
+  }
+  function _ParseResult___init__impl__gvz3cn(value) {
+    return value;
+  }
+  function _ParseResult___get_value__impl__86mnxf($this) {
+    return $this;
+  }
+  function Companion_2() {
+  }
+  protoOf(Companion_2).cl = function (indexOfNextUnparsed) {
+    return _ParseResult___init__impl__gvz3cn(indexOfNextUnparsed);
+  };
+  protoOf(Companion_2).dl = function (position, message) {
+    return _ParseResult___init__impl__gvz3cn(new ParseError(position, message));
+  };
+  var Companion_instance_2;
+  function Companion_getInstance_2() {
+    return Companion_instance_2;
+  }
+  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.el_1.vh();
+      var inputPosition = state.gl_1;
+      var parserStructure = state.fl_1;
+      // Inline function 'kotlin.run' call
+      var this_0 = new Parser($this);
+      // Inline function 'kotlin.contracts.contract' call
+      $l$block: {
+        // Inline function 'kotlinx.datetime.internal.format.parser.Parser.parse.<anonymous>' call
+        this_0.hl_1;
+        var inductionVariable = 0;
+        var last = parserStructure.il_1.o() - 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_1 = parserStructure.il_1.n(ix).kl(output, input, inputPosition);
+            var tmp0_subject = _ParseResult___get_value__impl__86mnxf(this_1);
+            var tmp_0;
+            if (typeof tmp0_subject === 'number') {
+              inputPosition = _ParseResult___get_value__impl__86mnxf(this_1);
+              tmp_0 = Unit_instance;
+            } else {
+              if (tmp0_subject instanceof ParseError) {
+                // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+                var it = _ParseResult___get_value__impl__86mnxf(this_1);
+                errors.e(it);
+                break $l$block;
+              } else {
+                var message = 'Unexpected parse result: ' + toString(_ParseResult___get_value__impl__86mnxf(this_1));
+                throw IllegalStateException_init_$Create$(toString(message));
+              }
+            }
+          }
+           while (inductionVariable <= last);
+        if (parserStructure.jl_1.m()) {
+          if (false || inputPosition === charSequenceLength(input)) {
+            // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+            return output;
+          } else {
+            // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+            var tmp_1 = inputPosition;
+            var it_0 = new ParseError(tmp_1, Parser$match$lambda);
+            errors.e(it_0);
+          }
+        } else {
+          var inductionVariable_0 = parserStructure.jl_1.o() - 1 | 0;
+          if (0 <= inductionVariable_0)
+            do {
+              var ix_0 = inductionVariable_0;
+              inductionVariable_0 = inductionVariable_0 + -1 | 0;
+              parseOptions.e(new ParserState(output, parserStructure.jl_1.n(ix_0), inputPosition));
+            }
+             while (0 <= inductionVariable_0);
+        }
+      }
+    }
+    // Inline function 'kotlin.collections.sortByDescending' call
+    if (errors.o() > 1) {
+      // Inline function 'kotlin.comparisons.compareByDescending' call
+      var tmp_2 = Parser$match$lambda_0;
+      var tmp$ret$4 = new sam$kotlin_Comparator$0(tmp_2);
+      sortWith(errors, tmp$ret$4);
+    }
+    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)).ll.call(new Parser($this), input, initialContainer, startIndex);
+    }
+    return tmp;
+  }
+  function ParserState(output, parserStructure, inputPosition) {
+    this.el_1 = output;
+    this.fl_1 = parserStructure;
+    this.gl_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.hl_1 : THROW_CCE();
+    if (!equals($this, tmp0_other_with_cast))
+      return false;
+    return true;
+  }
+  function sam$kotlin_Comparator$0(function_0) {
+    this.ml_1 = function_0;
+  }
+  protoOf(sam$kotlin_Comparator$0).mb = function (a, b) {
+    return this.ml_1(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0).compare = function (a, b) {
+    return this.mb(a, b);
+  };
+  protoOf(sam$kotlin_Comparator$0).e3 = function () {
+    return this.ml_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.e3(), other.e3());
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(sam$kotlin_Comparator$0).hashCode = function () {
+    return hashCode(this.e3());
+  };
+  function Parser$match$lambda() {
+    return 'There is more input to consume';
+  }
+  function Parser$match$lambda_0(a, b) {
+    // Inline function 'kotlin.comparisons.compareValuesBy' call
+    // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+    var tmp = b.al_1;
+    // Inline function 'kotlinx.datetime.internal.format.parser.Parser.match.<anonymous>' call
+    var tmp$ret$1 = a.al_1;
+    return compareValues(tmp, tmp$ret$1);
+  }
+  function Parser(commands) {
+    this.hl_1 = commands;
+  }
+  protoOf(Parser).toString = function () {
+    return Parser__toString_impl_x33iea(this.hl_1);
+  };
+  protoOf(Parser).hashCode = function () {
+    return Parser__hashCode_impl_bbxllf(this.hl_1);
+  };
+  protoOf(Parser).equals = function (other) {
+    return Parser__equals_impl_djxokv(this.hl_1, other);
+  };
+  function ParserStructure(operations, followedBy) {
+    this.il_1 = operations;
+    this.jl_1 = followedBy;
+  }
+  protoOf(ParserStructure).toString = function () {
+    return joinToString(this.il_1, ', ') + '(' + joinToString(this.jl_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.m()) {
+      var iterator = _this__u8e3s4.q(_this__u8e3s4.o());
+      while (iterator.j4()) {
+        // Inline function 'kotlinx.datetime.internal.format.parser.concat.<anonymous>' call
+        var parser = iterator.l4();
+        var acc = accumulator;
+        accumulator = concat$append(parser, acc);
+      }
+    }
+    var naiveParser = accumulator;
+    return concat$simplify(naiveParser, emptyList());
+  }
+  function formatError(errors) {
+    if (errors.o() === 1) {
+      return 'Position ' + errors.n(0).al_1 + ': ' + errors.n(0).bl_1();
+    }
+    var averageMessageLength = 33;
+    var tmp0_buffer = StringBuilder_init_$Create$_0(imul(averageMessageLength, errors.o()));
+    return joinTo(errors, tmp0_buffer, ', ', 'Errors: ', VOID, VOID, VOID, formatError$lambda).toString();
+  }
+  function concat$append(_this__u8e3s4, other) {
+    var tmp;
+    if (_this__u8e3s4.jl_1.m()) {
+      tmp = new ParserStructure(plus(_this__u8e3s4.il_1, other.il_1), other.jl_1);
+    } else {
+      // Inline function 'kotlin.collections.map' call
+      var this_0 = _this__u8e3s4.jl_1;
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+      var tmp0_iterator = this_0.j();
+      while (tmp0_iterator.k()) {
+        var item = tmp0_iterator.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.concat.append.<anonymous>' call
+        var tmp$ret$0 = concat$append(item, other);
+        destination.e(tmp$ret$0);
+      }
+      tmp = new ParserStructure(_this__u8e3s4.il_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 tmp0_iterator = _this__u8e3s4.il_1.j();
+    while (tmp0_iterator.k()) {
+      var op = tmp0_iterator.l();
+      if (op instanceof NumberSpanParserOperation) {
+        if (!(currentNumberSpan == null)) {
+          currentNumberSpan.p(op.nl_1);
+        } else {
+          currentNumberSpan = toMutableList(op.nl_1);
+        }
+      } else {
+        if (op instanceof UnconditionalModification) {
+          unconditionalModificationsForTails.e(op);
+        } else {
+          if (!(currentNumberSpan == null)) {
+            newOperations.e(new NumberSpanParserOperation(currentNumberSpan));
+            currentNumberSpan = null;
+          }
+          newOperations.e(op);
+        }
+      }
+    }
+    // Inline function 'kotlin.collections.ifEmpty' call
+    // Inline function 'kotlin.collections.flatMap' call
+    // Inline function 'kotlin.collections.flatMapTo' call
+    var this_0 = _this__u8e3s4.jl_1;
+    var destination = ArrayList_init_$Create$();
+    var tmp0_iterator_0 = this_0.j();
+    while (tmp0_iterator_0.k()) {
+      var element = tmp0_iterator_0.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+      var simplified = concat$simplify(element, unconditionalModificationsForTails);
+      var tmp;
+      if (simplified.il_1.m()) {
+        // Inline function 'kotlin.collections.ifEmpty' call
+        var this_1 = simplified.jl_1;
+        // Inline function 'kotlin.contracts.contract' call
+        var tmp_0;
+        if (this_1.m()) {
+          // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>.<anonymous>' call
+          tmp_0 = listOf(simplified);
+        } else {
+          tmp_0 = this_1;
+        }
+        tmp = tmp_0;
+      } else {
+        tmp = listOf(simplified);
+      }
+      var list = tmp;
+      addAll(destination, list);
+    }
+    // Inline function 'kotlin.contracts.contract' call
+    var tmp_1;
+    if (destination.m()) {
+      // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+      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.m();
+        } else {
+          tmp_3 = false;
+        }
+        if (tmp_3) {
+          tmp$ret$8 = true;
+          break $l$block_0;
+        }
+        var tmp0_iterator_1 = mergedTails.j();
+        while (tmp0_iterator_1.k()) {
+          var element_0 = tmp0_iterator_1.l();
+          // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+          var tmp0_safe_receiver = firstOrNull(element_0.il_1);
+          var tmp_4;
+          if (tmp0_safe_receiver == null) {
+            tmp_4 = null;
+          } else {
+            // Inline function 'kotlin.let' call
+            // Inline function 'kotlin.contracts.contract' call
+            // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>.<anonymous>' 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.e(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 tmp0_iterator_2 = mergedTails.j();
+        while (tmp0_iterator_2.k()) {
+          var item = tmp0_iterator_2.l();
+          // Inline function 'kotlinx.datetime.internal.format.parser.concat.simplify.<anonymous>' call
+          var firstOperation = firstOrNull(item.il_1);
+          var tmp_5;
+          if (firstOperation instanceof NumberSpanParserOperation) {
+            tmp_5 = new ParserStructure(plus(listOf(new NumberSpanParserOperation(plus(currentNumberSpan, firstOperation.nl_1))), drop(item.il_1, 1)), item.jl_1);
+          } else {
+            if (firstOperation == null) {
+              tmp_5 = new ParserStructure(listOf(new NumberSpanParserOperation(currentNumberSpan)), item.jl_1);
+            } else {
+              tmp_5 = new ParserStructure(plus(listOf(new NumberSpanParserOperation(currentNumberSpan)), item.il_1), item.jl_1);
+            }
+          }
+          var tmp$ret$12 = tmp_5;
+          destination_0.e(tmp$ret$12);
+        }
+        var newTails = destination_0;
+        tmp_2 = new ParserStructure(newOperations, newTails);
+      }
+    }
+    return tmp_2;
+  }
+  function formatError$lambda(it) {
+    return 'position ' + it.al_1 + ": '" + it.bl_1() + "'";
+  }
+  function SignedIntParser(minDigits, maxDigits, spacePadding, setter, name, plusOnExceedsWidth) {
+    var parsers = mutableListOf([spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name, true)]);
+    if (!(plusOnExceedsWidth == null)) {
+      parsers.e(spaceAndZeroPaddedUnsignedInt(minDigits, plusOnExceedsWidth, spacePadding, setter, name));
+      parsers.e(new ParserStructure(listOf_0([new PlainStringParserOperation('+'), new NumberSpanParserOperation(listOf(new UnsignedIntConsumer(plusOnExceedsWidth + 1 | 0, maxDigits, setter, name, false)))]), emptyList()));
+    } else {
+      parsers.e(spaceAndZeroPaddedUnsignedInt(minDigits, maxDigits, spacePadding, setter, name));
+    }
+    return new ParserStructure(emptyList(), parsers);
+  }
+  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
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlinx.datetime.internal.format.parser.spaceAndZeroPaddedUnsignedInt.<anonymous>' 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.nl_1;
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$_0(collectionSizeOrDefault(this_0, 10));
+    var tmp0_iterator = this_0.j();
+    while (tmp0_iterator.k()) {
+      var item = tmp0_iterator.l();
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<get-whatThisExpects>.<anonymous>' call
+      var length = item.a();
+      var tmp$ret$0 = (length == null ? 'at least one digit' : '' + length + ' digits') + (' for ' + item.ok_1);
+      destination.e(tmp$ret$0);
+    }
+    var consumerLengths = destination;
+    var tmp;
+    if ($this.pl_1) {
+      tmp = 'a number with at least ' + $this.ol_1 + ' digits: ' + toString(consumerLengths);
+    } else {
+      tmp = 'a number with exactly ' + $this.ol_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.nl_1.n($i).ok_1 + ': ' + $error.pk();
+    };
+  }
+  function NumberSpanParserOperation(consumers) {
+    this.nl_1 = consumers;
+    var tmp = this;
+    // Inline function 'kotlin.collections.sumOf' call
+    var sum = 0;
+    var tmp0_iterator = this.nl_1.j();
+    while (tmp0_iterator.k()) {
+      var element = tmp0_iterator.l();
+      var tmp_0 = sum;
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.minLength.<anonymous>' call
+      var tmp0_elvis_lhs = element.a();
+      sum = tmp_0 + (tmp0_elvis_lhs == null ? 1 : tmp0_elvis_lhs) | 0;
+    }
+    tmp.ol_1 = sum;
+    var tmp_1 = this;
+    var tmp$ret$2;
+    $l$block_0: {
+      // Inline function 'kotlin.collections.any' call
+      var this_0 = this.nl_1;
+      var tmp_2;
+      if (isInterface(this_0, Collection)) {
+        tmp_2 = this_0.m();
+      } else {
+        tmp_2 = false;
+      }
+      if (tmp_2) {
+        tmp$ret$2 = false;
+        break $l$block_0;
+      }
+      var tmp0_iterator_0 = this_0.j();
+      while (tmp0_iterator_0.k()) {
+        var element_0 = tmp0_iterator_0.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.isFlexible.<anonymous>' call
+        if (element_0.a() == null) {
+          tmp$ret$2 = true;
+          break $l$block_0;
+        }
+      }
+      tmp$ret$2 = false;
+    }
+    tmp_1.pl_1 = tmp$ret$2;
+    // Inline function 'kotlin.require' call
+    var tmp$ret$4;
+    $l$block_2: {
+      // Inline function 'kotlin.collections.all' call
+      var this_1 = this.nl_1;
+      var tmp_3;
+      if (isInterface(this_1, Collection)) {
+        tmp_3 = this_1.m();
+      } else {
+        tmp_3 = false;
+      }
+      if (tmp_3) {
+        tmp$ret$4 = true;
+        break $l$block_2;
+      }
+      var tmp0_iterator_1 = this_1.j();
+      while (tmp0_iterator_1.k()) {
+        var element_1 = tmp0_iterator_1.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>' call
+        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.contracts.contract' call
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!tmp$ret$4) {
+      // Inline function 'kotlin.require.<anonymous>' call
+      var message = 'Failed requirement.';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    var tmp$ret$7;
+    $l$block_3: {
+      // Inline function 'kotlin.collections.count' call
+      var this_2 = this.nl_1;
+      var tmp_4;
+      if (isInterface(this_2, Collection)) {
+        tmp_4 = this_2.m();
+      } else {
+        tmp_4 = false;
+      }
+      if (tmp_4) {
+        tmp$ret$7 = 0;
+        break $l$block_3;
+      }
+      var count = 0;
+      var tmp0_iterator_2 = this_2.j();
+      while (tmp0_iterator_2.k()) {
+        var element_2 = tmp0_iterator_2.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>' call
+        if (element_2.a() == null) {
+          count = count + 1 | 0;
+          checkCountOverflow(count);
+        }
+      }
+      tmp$ret$7 = count;
+    }
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(tmp$ret$7 <= 1)) {
+      // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>' call
+      // Inline function 'kotlin.collections.map' call
+      // Inline function 'kotlin.collections.filter' call
+      // Inline function 'kotlin.collections.filterTo' call
+      var this_3 = this.nl_1;
+      var destination = ArrayList_init_$Create$();
+      var tmp0_iterator_3 = this_3.j();
+      while (tmp0_iterator_3.k()) {
+        var element_3 = tmp0_iterator_3.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>.<anonymous>' call
+        if (element_3.a() == null) {
+          destination.e(element_3);
+        }
+      }
+      // Inline function 'kotlin.collections.mapTo' call
+      var destination_0 = ArrayList_init_$Create$_0(collectionSizeOrDefault(destination, 10));
+      var tmp0_iterator_4 = destination.j();
+      while (tmp0_iterator_4.k()) {
+        var item = tmp0_iterator_4.l();
+        // Inline function 'kotlinx.datetime.internal.format.parser.NumberSpanParserOperation.<anonymous>.<anonymous>' call
+        var tmp$ret$12 = item.ok_1;
+        destination_0.e(tmp$ret$12);
+      }
+      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).kl = function (storage, input, startIndex) {
+    if ((startIndex + this.ol_1 | 0) > charSequenceLength(input)) {
+      var tmp = Companion_instance_2;
+      return tmp.dl(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.ol_1) {
+      var tmp_0 = Companion_instance_2;
+      return tmp_0.dl(startIndex, NumberSpanParserOperation$consume$lambda_0(digitsInRow, this));
+    }
+    var index = startIndex;
+    var inductionVariable = 0;
+    var last = this.nl_1.o() - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var tmp1_elvis_lhs = this.nl_1.n(i).a();
+        var length = tmp1_elvis_lhs == null ? (digitsInRow._v - this.ol_1 | 0) + 1 | 0 : tmp1_elvis_lhs;
+        var error = this.nl_1.n(i).mk(storage, input, index, index + length | 0);
+        if (!(error == null)) {
+          // Inline function 'kotlin.text.substring' call
+          var startIndex_0 = index;
+          var endIndex = index + length | 0;
+          var numberString = toString(charSequenceSubSequence(input, startIndex_0, endIndex));
+          var tmp_1 = Companion_instance_2;
+          var tmp_2 = index;
+          return tmp_1.dl(tmp_2, NumberSpanParserOperation$consume$lambda_1(numberString, this, i, error));
+        }
+        index = index + length | 0;
+      }
+       while (inductionVariable <= last);
+    return Companion_instance_2.cl(index);
+  };
+  protoOf(NumberSpanParserOperation).toString = function () {
+    return _get_whatThisExpects__4pg11j(this);
+  };
+  function PlainStringParserOperation$consume$lambda(this$0) {
+    return function () {
+      return "Unexpected end of input: yet to parse '" + this$0.ql_1 + "'";
+    };
+  }
+  function PlainStringParserOperation$consume$lambda_0(this$0, $input, $startIndex, $i) {
+    return function () {
+      // Inline function 'kotlin.text.substring' call
+      var this_0 = $input;
+      var startIndex = $startIndex;
+      var endIndex = ($startIndex + $i | 0) + 1 | 0;
+      var tmp$ret$0 = toString(charSequenceSubSequence(this_0, startIndex, endIndex));
+      return 'Expected ' + this$0.ql_1 + ' but got ' + tmp$ret$0;
+    };
+  }
+  function PlainStringParserOperation(string) {
+    this.ql_1 = string;
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.text.isNotEmpty' call
+    var this_0 = this.ql_1;
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(charSequenceLength(this_0) > 0)) {
+      // Inline function 'kotlinx.datetime.internal.format.parser.PlainStringParserOperation.<anonymous>' call
+      var message = 'Empty string is not allowed';
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!!isAsciiDigit(charSequenceGet(this.ql_1, 0))) {
+      // Inline function 'kotlinx.datetime.internal.format.parser.PlainStringParserOperation.<anonymous>' call
+      var message_0 = "String '" + this.ql_1 + "' starts with a digit";
+      throw IllegalArgumentException_init_$Create$(toString(message_0));
+    }
+    // Inline function 'kotlin.require' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!!isAsciiDigit(charSequenceGet(this.ql_1, this.ql_1.length - 1 | 0))) {
+      // Inline function 'kotlinx.datetime.internal.format.parser.PlainStringParserOperation.<anonymous>' call
+      var message_1 = "String '" + this.ql_1 + "' ends with a digit";
+      throw IllegalArgumentException_init_$Create$(toString(message_1));
+    }
+  }
+  protoOf(PlainStringParserOperation).kl = function (storage, input, startIndex) {
+    if ((startIndex + this.ql_1.length | 0) > charSequenceLength(input)) {
+      var tmp = Companion_instance_2;
+      return tmp.dl(startIndex, PlainStringParserOperation$consume$lambda(this));
+    }
+    var inductionVariable = 0;
+    var last = charSequenceLength(this.ql_1) - 1 | 0;
+    if (inductionVariable <= last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        if (!(charSequenceGet(input, startIndex + i | 0) === charSequenceGet(this.ql_1, i))) {
+          var tmp_0 = Companion_instance_2;
+          return tmp_0.dl(startIndex, PlainStringParserOperation$consume$lambda_0(this, input, startIndex, i));
+        }
+      }
+       while (inductionVariable <= last);
+    return Companion_instance_2.cl(startIndex + this.ql_1.length | 0);
+  };
+  protoOf(PlainStringParserOperation).toString = function () {
+    return "'" + this.ql_1 + "'";
+  };
+  function UnconditionalModification() {
+  }
+  function spaceAndZeroPaddedUnsignedInt$numberOfRequiredLengths($withMinus, $setter, $name, minNumberLength, maxNumberLength) {
+    // Inline function 'kotlin.check' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.check' call
+    // Inline function 'kotlin.contracts.contract' call
+    if (!(maxNumberLength >= (1 + ($withMinus ? 1 : 0) | 0))) {
+      // Inline function 'kotlin.check.<anonymous>' call
+      var message = 'Check failed.';
+      throw IllegalStateException_init_$Create$(toString(message));
+    }
+    // Inline function 'kotlin.collections.buildList' call
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlin.collections.buildListInternal' call
+    // Inline function 'kotlin.apply' call
+    var this_0 = ArrayList_init_$Create$();
+    // Inline function 'kotlin.contracts.contract' call
+    // Inline function 'kotlinx.datetime.internal.format.parser.spaceAndZeroPaddedUnsignedInt.numberOfRequiredLengths.<anonymous>' call
+    if ($withMinus) {
+      this_0.e(new PlainStringParserOperation('-'));
+    }
+    this_0.e(new NumberSpanParserOperation(listOf(new UnsignedIntConsumer(minNumberLength - ($withMinus ? 1 : 0) | 0, maxNumberLength - ($withMinus ? 1 : 0) | 0, $setter, $name, $withMinus))));
+    var tmp$ret$3 = this_0.d5();
+    return new ParserStructure(tmp$ret$3, emptyList());
+  }
+  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));
+  }
+  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_0('MONDAY', 0);
+    DayOfWeek_TUESDAY_instance = new DayOfWeek_0('TUESDAY', 1);
+    DayOfWeek_WEDNESDAY_instance = new DayOfWeek_0('WEDNESDAY', 2);
+    DayOfWeek_THURSDAY_instance = new DayOfWeek_0('THURSDAY', 3);
+    DayOfWeek_FRIDAY_instance = new DayOfWeek_0('FRIDAY', 4);
+    DayOfWeek_SATURDAY_instance = new DayOfWeek_0('SATURDAY', 5);
+    DayOfWeek_SUNDAY_instance = new DayOfWeek_0('SUNDAY', 6);
+  }
+  var $ENTRIES;
+  function DayOfWeek_0(name, ordinal) {
+    Enum.call(this, name, ordinal);
+  }
+  function toDayOfWeek(_this__u8e3s4) {
+    return DayOfWeek(_this__u8e3s4.value());
+  }
+  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 Instant() {
+  }
+  function isJodaDateTimeParseException(_this__u8e3s4) {
+    return hasJsExceptionName(_this__u8e3s4, 'DateTimeParseException');
+  }
+  function isJodaDateTimeException(_this__u8e3s4) {
+    return hasJsExceptionName(_this__u8e3s4, 'DateTimeException');
+  }
+  function isJodaArithmeticException(_this__u8e3s4) {
+    return hasJsExceptionName(_this__u8e3s4, 'ArithmeticException');
+  }
+  function Companion_3() {
+    Companion_instance_3 = this;
+    this.rl_1 = new LocalDate_0(LocalDate.MIN);
+    this.sl_1 = new LocalDate_0(LocalDate.MAX);
+  }
+  protoOf(Companion_3).tl = function (input, format) {
+    var tmp;
+    if (format === Formats_getInstance().lg()) {
+      var tmp_0;
+      try {
+        // Inline function 'kotlin.let' call
+        // Inline function 'kotlinx.datetime.jsTry' call
+        // Inline function 'kotlinx.datetime.Companion.parse.<anonymous>' call
+        // Inline function 'kotlin.contracts.contract' call
+        var p0 = LocalDate.parse(toString(input));
+        tmp_0 = new LocalDate_0(p0);
+      } catch ($p) {
+        var tmp_1;
+        if ($p instanceof Error) {
+          var e = $p;
+          if (isJodaDateTimeParseException(e))
+            throw DateTimeFormatException_init_$Create$_1(e);
+          throw e;
+        } else {
+          throw $p;
+        }
+      }
+      tmp = tmp_0;
+    } else {
+      tmp = format.pg(input);
+    }
+    return tmp;
+  };
+  protoOf(Companion_3).ul = function (input, format, $super) {
+    format = format === VOID ? getIsoDateFormat() : format;
+    return $super === VOID ? this.tl(input, format) : $super.tl.call(this, input, format);
+  };
+  var Companion_instance_3;
+  function Companion_getInstance_3() {
+    if (Companion_instance_3 == null)
+      new Companion_3();
+    return Companion_instance_3;
+  }
+  function Formats() {
+    Formats_instance = this;
+    this.kg_1 = get_ISO_DATE_BASIC();
+  }
+  protoOf(Formats).lg = function () {
+    return get_ISO_DATE();
+  };
+  var Formats_instance;
+  function Formats_getInstance() {
+    if (Formats_instance == null)
+      new Formats();
+    return Formats_instance;
+  }
+  function LocalDate_init_$Init$(year, monthNumber, dayOfMonth, $this) {
+    var tmp;
+    try {
+      // Inline function 'kotlinx.datetime.jsTry' call
+      // Inline function 'kotlinx.datetime.LocalDate.<init>.<anonymous>' call
+      tmp = LocalDate.of(year, monthNumber, dayOfMonth);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Error) {
+        var e = $p;
+        if (isJodaDateTimeException(e))
+          throw IllegalArgumentException_init_$Create$_0(e);
+        throw e;
+      } else {
+        throw $p;
+      }
+    }
+    LocalDate_0.call($this, tmp);
+    return $this;
+  }
+  function LocalDate_init_$Create$(year, monthNumber, dayOfMonth) {
+    return LocalDate_init_$Init$(year, monthNumber, dayOfMonth, objectCreate(protoOf(LocalDate_0)));
+  }
+  function LocalDate_0(value) {
+    Companion_getInstance_3();
+    this.th_1 = value;
+  }
+  protoOf(LocalDate_0).uh = function () {
+    return toDayOfWeek(this.th_1.dayOfWeek());
+  };
+  protoOf(LocalDate_0).equals = function (other) {
+    var tmp;
+    if (this === other) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (other instanceof LocalDate_0) {
+        tmp_0 = this.th_1 === other.th_1 || this.th_1.equals(other.th_1);
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(LocalDate_0).hashCode = function () {
+    return this.th_1.hashCode();
+  };
+  protoOf(LocalDate_0).toString = function () {
+    return this.th_1.toString();
+  };
+  protoOf(LocalDate_0).vl = function (other) {
+    return this.th_1.compareTo(other.th_1);
+  };
+  protoOf(LocalDate_0).d = function (other) {
+    return this.vl(other instanceof LocalDate_0 ? other : THROW_CCE());
+  };
+  protoOf(LocalDate_0).wl = function () {
+    return numberToInt(this.th_1.toEpochDay());
+  };
+  function plus_0(_this__u8e3s4, period) {
+    var tmp;
+    try {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlin.with' call
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlinx.datetime.plus.<anonymous>' call
+      // Inline function 'kotlin.run' call
+      // Inline function 'kotlin.run' call
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>' call
+      var $this$run = _this__u8e3s4.th_1;
+      var tmp_0;
+      if (!(period.zf_1 === 0)) {
+        // Inline function 'kotlinx.datetime.jsTry' call
+        // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>.<anonymous>' call
+        tmp_0 = $this$run.plusMonths(period.zf_1);
+      } else {
+        tmp_0 = $this$run;
+      }
+      // Inline function 'kotlin.contracts.contract' call
+      // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>' call
+      var $this$run_0 = tmp_0;
+      var tmp_1;
+      if (!(period.ag_1 === 0)) {
+        // Inline function 'kotlinx.datetime.jsTry' call
+        // Inline function 'kotlinx.datetime.plus.<anonymous>.<anonymous>.<anonymous>' call
+        tmp_1 = $this$run_0.plusDays(period.ag_1);
+      } else {
+        tmp_1 = $this$run_0;
+      }
+      // Inline function 'kotlin.contracts.contract' call
+      var p0 = tmp_1;
+      tmp = new LocalDate_0(p0);
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof Error) {
+        var e = $p;
+        if (isJodaDateTimeException(e) || isJodaArithmeticException(e))
+          throw DateTimeArithmeticException_init_$Create$_0(e);
+        throw e;
+      } else {
+        throw $p;
+      }
+    }
+    return tmp;
+  }
+  function daysUntil(_this__u8e3s4, other) {
+    return numberToInt(_this__u8e3s4.th_1.until(other.th_1, ChronoUnit.DAYS));
+  }
+  function monthsUntil(_this__u8e3s4, other) {
+    return numberToInt(_this__u8e3s4.th_1.until(other.th_1, ChronoUnit.MONTHS));
+  }
+  function yearsUntil(_this__u8e3s4, other) {
+    return numberToInt(_this__u8e3s4.th_1.until(other.th_1, ChronoUnit.YEARS));
+  }
+  function Companion_4() {
+    Companion_instance_4 = this;
+    this.xl_1 = new LocalDateTime_0(LocalDateTime.MIN);
+    this.yl_1 = new LocalDateTime_0(LocalDateTime.MAX);
+  }
+  var Companion_instance_4;
+  function Companion_getInstance_4() {
+    if (Companion_instance_4 == null)
+      new Companion_4();
+    return Companion_instance_4;
+  }
+  function LocalDateTime_0(value) {
+    Companion_getInstance_4();
+    this.zl_1 = value;
+  }
+  protoOf(LocalDateTime_0).am = function () {
+    return new LocalDate_0(this.zl_1.toLocalDate());
+  };
+  protoOf(LocalDateTime_0).equals = function (other) {
+    var tmp;
+    if (this === other) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (other instanceof LocalDateTime_0) {
+        tmp_0 = this.zl_1 === other.zl_1 || this.zl_1.equals(other.zl_1);
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(LocalDateTime_0).hashCode = function () {
+    return this.zl_1.hashCode();
+  };
+  protoOf(LocalDateTime_0).toString = function () {
+    return this.zl_1.toString();
+  };
+  protoOf(LocalDateTime_0).bm = function (other) {
+    return this.zl_1.compareTo(other.zl_1);
+  };
+  protoOf(LocalDateTime_0).d = function (other) {
+    return this.bm(other instanceof LocalDateTime_0 ? other : THROW_CCE());
+  };
+  function ofZone($this, zoneId) {
+    var tmp;
+    if (zoneId instanceof ZoneOffset) {
+      tmp = FixedOffsetTimeZone_init_$Create$(new UtcOffset(zoneId));
+    } else {
+      if (zoneId.rules().isFixedOffset()) {
+        var tmp_0 = zoneId.normalized();
+        tmp = new FixedOffsetTimeZone(new UtcOffset(tmp_0 instanceof ZoneOffset ? tmp_0 : THROW_CCE()), zoneId);
+      } else {
+        tmp = new TimeZone(zoneId);
+      }
+    }
+    return tmp;
+  }
+  function Companion_5() {
+    Companion_instance_5 = this;
+    this.cm_1 = asTimeZone(new UtcOffset(ZoneOffset.UTC));
+  }
+  protoOf(Companion_5).dm = function () {
+    return ofZone(this, ZoneId.systemDefault());
+  };
+  var Companion_instance_5;
+  function Companion_getInstance_5() {
+    if (Companion_instance_5 == null)
+      new Companion_5();
+    return Companion_instance_5;
+  }
+  function TimeZone(zoneId) {
+    Companion_getInstance_5();
+    this.em_1 = zoneId;
+  }
+  protoOf(TimeZone).equals = function (other) {
+    var tmp;
+    if (this === other) {
+      tmp = true;
+    } else {
+      var tmp_0;
+      if (other instanceof TimeZone) {
+        tmp_0 = this.em_1 === other.em_1 || this.em_1.equals(other.em_1);
+      } else {
+        tmp_0 = false;
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  };
+  protoOf(TimeZone).hashCode = function () {
+    return this.em_1.hashCode();
+  };
+  protoOf(TimeZone).toString = function () {
+    return this.em_1.toString();
+  };
+  function toLocalDateTime(_this__u8e3s4, timeZone) {
+    var tmp;
+    try {
+      // Inline function 'kotlin.let' call
+      // Inline function 'kotlinx.datetime.jsTry' call
+      // Inline function 'kotlinx.datetime.toLocalDateTime.<anonymous>' call
+      // Inline function 'kotlin.contracts.contract' call
+      var p0 = LocalDateTime.ofInstant(_this__u8e3s4.fm_1, timeZone.em_1);
+      tmp = new LocalDateTime_0(p0);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof Error) {
+        var e = $p;
+        if (isJodaDateTimeException(e))
+          throw DateTimeArithmeticException_init_$Create$_0(e);
+        throw e;
+      } else {
+        throw $p;
+      }
+    }
+    return tmp;
+  }
+  function FixedOffsetTimeZone_init_$Init$(offset, $this) {
+    FixedOffsetTimeZone.call($this, offset, offset.gm_1);
+    return $this;
+  }
+  function FixedOffsetTimeZone_init_$Create$(offset) {
+    return FixedOffsetTimeZone_init_$Init$(offset, objectCreate(protoOf(FixedOffsetTimeZone)));
+  }
+  function Companion_6() {
+  }
+  var Companion_instance_6;
+  function Companion_getInstance_6() {
+    return Companion_instance_6;
+  }
+  function FixedOffsetTimeZone(offset, zoneId) {
+    TimeZone.call(this, zoneId);
+    this.im_1 = offset;
+  }
+  function Companion_7() {
+    Companion_instance_7 = this;
+    this.jm_1 = new UtcOffset(ZoneOffset.UTC);
+  }
+  var Companion_instance_7;
+  function Companion_getInstance_7() {
+    if (Companion_instance_7 == null)
+      new Companion_7();
+    return Companion_instance_7;
+  }
+  function UtcOffset(zoneOffset) {
+    Companion_getInstance_7();
+    this.gm_1 = zoneOffset;
+  }
+  protoOf(UtcOffset).hashCode = function () {
+    return this.gm_1.hashCode();
+  };
+  protoOf(UtcOffset).equals = function (other) {
+    var tmp;
+    if (other instanceof UtcOffset) {
+      tmp = this.gm_1 === other.gm_1 || this.gm_1.equals(other.gm_1);
+    } else {
+      tmp = false;
+    }
+    return tmp;
+  };
+  protoOf(UtcOffset).toString = function () {
+    return this.gm_1.toString();
+  };
+  function hasJsExceptionName(_this__u8e3s4, name) {
+    // Inline function 'kotlin.js.asDynamic' call
+    return _this__u8e3s4.name == name;
+  }
+  //region block: post-declaration
+  protoOf(Builder).ah = chars;
+  protoOf(Builder).eh = build;
+  protoOf(Builder).ug = year;
+  protoOf(Builder).vg = year$default;
+  protoOf(Builder).wg = monthNumber;
+  protoOf(Builder).xg = monthNumber$default;
+  protoOf(Builder).yg = dayOfMonth;
+  protoOf(Builder).zg = dayOfMonth$default;
+  protoOf(PropertyAccessor).gj = getterNotNull;
+  //endregion
+  //region block: init
+  Companion_instance = new Companion();
+  Companion_instance_0 = new Companion_0();
+  Companion_instance_1 = new Companion_1();
+  ExpectedInt_instance = new ExpectedInt();
+  Companion_instance_2 = new Companion_2();
+  Companion_instance_6 = new Companion_6();
+  //endregion
+  //region block: exports
+  _.$_$ = _.$_$ || {};
+  _.$_$.a = DatePeriod_init_$Create$;
+  _.$_$.b = Companion_getInstance_3;
+  _.$_$.c = Companion_getInstance_5;
+  _.$_$.d = Instant;
+  _.$_$.e = LocalDate_0;
+  _.$_$.f = daysUntil;
+  _.$_$.g = monthsUntil;
+  _.$_$.h = plus_0;
+  _.$_$.i = toLocalDateTime;
+  _.$_$.j = yearsUntil;
+  //endregion
+  return _;
+}(module.exports, require('@js-joda/core'), require('./kotlin-kotlin-stdlib.js')));
+
+//# sourceMappingURL=Kotlin-DateTime-library-kotlinx-datetime.js.map