@flock/wirespec 0.19.5 → 0.20.0-RC.1

package/kotest-kotest-property.mjs

@@ -0,0 +1,2501 @@
+import {
+  Unit_instance28fytmsmm6r23 as Unit_instance,
+  collectionSizeOrDefault36dulx8yinfqm as collectionSizeOrDefault,
+  ArrayList_init_$Create$3ivpeip4ouddx as ArrayList_init_$Create$,
+  noWhenBranchMatchedException2a6r7ubxgky5j as noWhenBranchMatchedException,
+  toString1pkumu07cwy4m as toString,
+  IllegalStateException_init_$Create$2429fvs1h56dm as IllegalStateException_init_$Create$,
+  generateSequence3b5pkcqrpr2fo as generateSequence,
+  flatten2xcyr6x6x7b3e as flatten,
+  protoOf180f3jzyo7rfj as protoOf,
+  VOID3gxj6tk5isa35 as VOID,
+  initMetadataForClassbxx6q50dy2s7 as initMetadataForClass,
+  initMetadataForCompanion1wyw17z38v6ac as initMetadataForCompanion,
+  toString30pk9tzaqopn as toString_0,
+  hashCodeq5arwsb9dgti as hashCode,
+  equals2au1ep9vhcato as equals,
+  getNumberHashCode2l4nbdcihl25f as getNumberHashCode,
+  emptyList1g2z5xcrvp2zy as emptyList,
+  lazy2hsh8ze7j6ikd as lazy,
+  THROW_CCE2g6jy02ryeudk as THROW_CCE,
+  distinct10qe1scfdvu5k as distinct,
+  ArrayList_init_$Create$1jemgvhi5v0js as ArrayList_init_$Create$_0,
+  initMetadataForObject1cxne3s9w65el as initMetadataForObject,
+  listOf1jh22dvmctj1r as listOf,
+  CoroutineImpl2sn3kjnwmfr10 as CoroutineImpl,
+  isInterface3d6p8outrmvmk as isInterface,
+  initMetadataForLambda3af3he42mmnh as initMetadataForLambda,
+  initMetadataForInterface1egvbzx539z91 as initMetadataForInterface,
+  Enum3alwj03lh1n41 as Enum,
+  EmptyCoroutineContext_getInstance10e98b8bnsvr1 as EmptyCoroutineContext_getInstance,
+  throwUninitializedPropertyAccessException14fok093f3k3t as throwUninitializedPropertyAccessException,
+  _Result___get_value__impl__bjfvqg3630bgmytqwyb as _Result___get_value__impl__bjfvqg,
+  _Result___init__impl__xyqfz83a5421h46yeyh as _Result___init__impl__xyqfz8,
+  Companion_instance25ullnynvxd0w as Companion_instance,
+  _Result___get_isSuccess__impl__sndoy83aknnjk4qd85h as _Result___get_isSuccess__impl__sndoy8,
+  throwOnFailure24snjmtlqgzo8 as throwOnFailure,
+  IllegalArgumentException_init_$Create$1j1aj36nbo0wg as IllegalArgumentException_init_$Create$,
+  startCoroutineUninterceptedOrReturnNonGeneratorVersionyfrrvzbtl8bf as startCoroutineUninterceptedOrReturnNonGeneratorVersion,
+  Continuation1aa2oekvx7jm7 as Continuation,
+  random234odtwlu7lq2 as random,
+  get_COROUTINE_SUSPENDED3ujt3p13qm4iy as get_COROUTINE_SUSPENDED,
+  numberRangeToNumber25vse2rgp6rs8 as numberRangeToNumber,
+  ClosedRangehokgr73im9z3 as ClosedRange,
+  containsztqhvjtb696l as contains,
+  toByte4i43936u611k as toByte,
+  _UByte___get_data__impl__jof9qrfg5oujomrowy as _UByte___get_data__impl__jof9qr,
+  _UInt___init__impl__l7qpdl3eewek7byy9h9 as _UInt___init__impl__l7qpdl,
+  UInt1hthisrv6cndi as UInt,
+  _UInt___get_data__impl__f0vqqw3lsr2hwtcnhrf as _UInt___get_data__impl__f0vqqw,
+  _UByte___init__impl__g9hnc418b8pq346rvu4 as _UByte___init__impl__g9hnc4,
+  UBytep4j7r1t64gz1 as UByte,
+  toByteArray3caw0hip00os as toByteArray,
+  first1cs6gg5jrulfl as first,
+  filter184huxd00uyfg as filter,
+  firstqtqxwgtggxw8 as first_0,
+  UIntRangemvq5a1vbdqql as UIntRange,
+  take3onnpy6q7ctcz as take,
+  dropLast1vpiyky649o34 as dropLast,
+  drop3na99dw9feawf as drop,
+  listOfvhqybd2zx248 as listOf_0,
+  KtList3hktaavzmj137 as KtList,
+  random1sf5nh8jpeq5r as random_0,
+  firstOrNull1982767dljvdy as firstOrNull,
+  listOfNotNull2woi2boe01ub4 as listOfNotNull,
+  nextInt2pxj3bzg1eemu as nextInt,
+  take2rh6pen3z50h7 as take_0,
+  toListx6x8nvfmvvht as toList,
+  rangeTo5xinnemk0fd3 as rangeTo,
+  plus310ted5e4i90h as plus,
+  RegexOption_IGNORE_CASE_getInstance2ohbx186qe23p as RegexOption_IGNORE_CASE_getInstance,
+  Regex_init_$Create$o3w44y7t0smx as Regex_init_$Create$,
+  isFinite2t9l5a275mxm6 as isFinite,
+  toDouble1kn912gjoizjp as toDouble,
+  listOfNotNull1v4ggfackvuny as listOfNotNull_0,
+  isCharSequence1ju9jr1w86plq as isCharSequence,
+  charSequenceLength3278n89t01tmv as charSequenceLength,
+  charSequenceGet1vxk1y5n17t1z as charSequenceGet,
+  _Char___init__impl__6a9atx1csff5kwtduxl as _Char___init__impl__6a9atx,
+  charSequenceSubSequence1iwpdba8s3jc7 as charSequenceSubSequence,
+  last2n4gf5az1lkn4 as last,
+  isDigit3mimrri4wkzop as isDigit,
+  take9j4462mea726 as take_1,
+  takeLast2r8kr8e6g6hi7 as takeLast,
+  dropLastlqc2oyv04br0 as dropLast_0,
+  rangeToeizvz34h11nd as rangeTo_0,
+  isFinite1tx0gn65nl9tj as isFinite_0,
+  abs1kdzbjes1idip as abs,
+  reversed22y3au42jl32b as reversed,
+  plus2lupu3ot2lvhl as plus_0,
+  distinct24ithjwsnuqq8 as distinct_0,
+  uintDivide3r5nfwgstcow1 as uintDivide,
+  UInt__toInt_impl_93yt4d1l5chk3dckogz as UInt__toInt_impl_93yt4d,
+  toUInt2yfjuryeoq592 as toUInt,
+  UInt__compareTo_impl_yacclj2qzfiopi3rnn0 as UInt__compareTo_impl_yacclj,
+  uintCompare18k97xs29243i as uintCompare,
+  Long2qws0ah9gnpki as Long,
+  longRangeToLong1wnzlyc7cu6kp as longRangeToLong,
+  longArrayOf1jqne2a8v34i5 as longArrayOf,
+  compare2uud5j30pw5xc as compare,
+  abs22kdeprm0tm5i as abs_0,
+  fromInt1lka3ktyu79a4 as fromInt,
+  divide3tol6kxdi8xn6 as divide,
+  multiply18i3gv3wlmcjg as multiply,
+  subtract16cg4lfi29fq9 as subtract,
+  equalsLong28bsrfhwvd686 as equalsLong,
+  nextLong1aiee7lbc67js as nextLong,
+  objectCreate1ve4bgxiu4x98 as objectCreate,
+  plus20p0vtfmu0596 as plus_1,
+  toLongkk4waq8msp1k as toLong,
+  Randomei1bbeye8rr8 as Random,
+  Default_getInstance1yflkybdrpcz6 as Default_getInstance,
+} from './kotlin-kotlin-stdlib.mjs';
+import {
+  sysprop1tygc7b8xvq3v as sysprop,
+  sysprop25ryjwiz3kcc3 as sysprop_0,
+  syspropm73f0zr5j4q2 as sysprop_1,
+  sysprop28jkvofav1dz as sysprop_2,
+  syspropvs0igg2iawwa as sysprop_3,
+} from './kotest-kotest-common.mjs';
+//region block: imports
+var imul = Math.imul;
+//endregion
+//region block: pre-declaration
+initMetadataForClass(Gen, 'Gen');
+initMetadataForCompanion(Companion);
+initMetadataForClass(Arb, 'Arb', VOID, Gen);
+initMetadataForClass(Sample, 'Sample');
+initMetadataForCompanion(Companion_0);
+initMetadataForClass(EdgeConfig, 'EdgeConfig', EdgeConfig);
+initMetadataForClass(Exhaustive, 'Exhaustive', VOID, Gen);
+initMetadataForClass(RTree, 'RTree');
+initMetadataForClass(bimap$1);
+initMetadataForClass(ShrinkingMode, 'ShrinkingMode');
+initMetadataForObject(Off, 'Off', VOID, ShrinkingMode);
+initMetadataForObject(Unbounded, 'Unbounded', VOID, ShrinkingMode);
+initMetadataForClass(Bounded, 'Bounded', VOID, ShrinkingMode);
+initMetadataForLambda(boolean$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForInterface(ArbitraryBuilderContext, 'ArbitraryBuilderContext', VOID, VOID, VOID, [1]);
+initMetadataForClass(SingleShotGenerationMode, 'SingleShotGenerationMode', VOID, Enum);
+initMetadataForClass(SingleShotArbContinuation, 'SingleShotArbContinuation', VOID, VOID, [Continuation], [1]);
+initMetadataForClass(Restricted, 'Restricted', VOID, SingleShotArbContinuation, [SingleShotArbContinuation, ArbitraryBuilderContext], [1]);
+initMetadataForCompanion(Companion_1);
+initMetadataForClass(ArbitraryBuilder$build$1, VOID, VOID, Arb);
+initMetadataForClass(ArbitraryBuilder, 'ArbitraryBuilder');
+initMetadataForLambda(arbitrary$o$delegate$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForClass(arbitrary$1, VOID, VOID, Arb);
+initMetadataForLambda(arbitraryBuilder$o$singleShotArb$slambda, CoroutineImpl, VOID, [1]);
+initMetadataForClass(arbitraryBuilder$1, VOID, VOID, Arb);
+initMetadataForLambda(arbitrary$o$delegate$slambda_1, CoroutineImpl, VOID, [2]);
+initMetadataForClass(arbitrary$2, VOID, VOID, Arb);
+initMetadataForLambda(arbitrary$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForLambda(arbitrary$o$delegate$slambda_3, CoroutineImpl, VOID, [2]);
+initMetadataForClass(arbitrary$5, VOID, VOID, Arb);
+initMetadataForLambda(byte$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForClass(ListShrinker, 'ListShrinker');
+initMetadataForLambda(element$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForLambda(element$slambda_1, CoroutineImpl, VOID, [2]);
+initMetadataForLambda(list$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForObject(DoubleShrinker, 'DoubleShrinker');
+initMetadataForLambda(double$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForObject(FloatShrinker, 'FloatShrinker');
+initMetadataForLambda(float$slambda, CoroutineImpl, VOID, [2]);
+initMetadataForClass(IntShrinker, 'IntShrinker');
+initMetadataForClass(UIntShrinker, 'UIntShrinker');
+initMetadataForClass(LongShrinker, 'LongShrinker');
+initMetadataForClass(TrampolineArb, 'TrampolineArb', VOID, Arb);
+initMetadataForClass(map$2$1, VOID, VOID, Arb);
+initMetadataForClass(IntClassifier, 'IntClassifier');
+initMetadataForClass(LongClassifier, 'LongClassifier');
+initMetadataForObject(PropertyTesting, 'PropertyTesting');
+initMetadataForClass(LabelOrder, 'LabelOrder', VOID, Enum);
+initMetadataForCompanion(Companion_2);
+initMetadataForClass(RandomSource, 'RandomSource');
+initMetadataForClass(StatisticsReportMode, 'StatisticsReportMode', VOID, Enum);
+initMetadataForObject(DefaultStatisticsReporter, 'DefaultStatisticsReporter', VOID, VOID, VOID, [3, 1]);
+//endregion
+function Gen$generate$lambda($rs, $edgeConfig, this$0, $samples) {
+  return function () {
+    var isEdgeCase = $rs.m6m_1.oi(0.0, 1.0) < $edgeConfig.o6m_1;
+    var tmp;
+    if (isEdgeCase) {
+      var tmp0_elvis_lhs = this$0.q6m($rs);
+      tmp = tmp0_elvis_lhs == null ? $samples.v() : tmp0_elvis_lhs;
+    } else {
+      tmp = $samples.v();
+    }
+    return tmp;
+  };
+}
+function Gen$generate$lambda_0(this$0) {
+  return function () {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = this$0.s2();
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s = this_0.t();
+    while (_iterator__ex2g4s.u()) {
+      var item = _iterator__ex2g4s.v();
+      var tmp$ret$0 = new Sample(item);
+      destination.y(tmp$ret$0);
+    }
+    return destination;
+  };
+}
+function Gen() {
+  this.s6m_1 = null;
+}
+protoOf(Gen).t6m = function (rs, edgeConfig) {
+  var tmp;
+  if (this instanceof Arb) {
+    var samples = this.u6m(rs).t();
+    tmp = generateSequence(Gen$generate$lambda(rs, edgeConfig, this, samples));
+  } else {
+    if (this instanceof Exhaustive) {
+      // Inline function 'kotlin.collections.isNotEmpty' call
+      // Inline function 'kotlin.check' call
+      if (!!this.s2().r()) {
+        var message = "Exhaustive.values shouldn't be a empty list.";
+        throw IllegalStateException_init_$Create$(toString(message));
+      }
+      tmp = flatten(generateSequence(Gen$generate$lambda_0(this)));
+    } else {
+      noWhenBranchMatchedException();
+    }
+  }
+  return tmp;
+};
+protoOf(Gen).v6m = function (rs, edgeConfig, $super) {
+  edgeConfig = edgeConfig === VOID ? default_0(Companion_instance_1) : edgeConfig;
+  return $super === VOID ? this.t6m(rs, edgeConfig) : $super.t6m.call(this, rs, edgeConfig);
+};
+function Companion() {
+}
+var Companion_instance_0;
+function Companion_getInstance() {
+  return Companion_instance_0;
+}
+function Arb$samples$lambda(this$0, $rs) {
+  return function () {
+    return this$0.w6m($rs);
+  };
+}
+function Arb() {
+  Gen.call(this);
+}
+protoOf(Arb).u6m = function (rs) {
+  return generateSequence(Arb$samples$lambda(this, rs));
+};
+function Sample$_init_$lambda_a4a8db($value) {
+  return function () {
+    return $value;
+  };
+}
+function Sample(value, shrinks) {
+  var tmp;
+  if (shrinks === VOID) {
+    tmp = new RTree(Sample$_init_$lambda_a4a8db(value));
+  } else {
+    tmp = shrinks;
+  }
+  shrinks = tmp;
+  this.x6m_1 = value;
+  this.y6m_1 = shrinks;
+}
+protoOf(Sample).toString = function () {
+  return 'Sample(value=' + toString_0(this.x6m_1) + ', shrinks=' + this.y6m_1.toString() + ')';
+};
+protoOf(Sample).hashCode = function () {
+  var result = this.x6m_1 == null ? 0 : hashCode(this.x6m_1);
+  result = imul(result, 31) + this.y6m_1.hashCode() | 0;
+  return result;
+};
+protoOf(Sample).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof Sample))
+    return false;
+  if (!equals(this.x6m_1, other.x6m_1))
+    return false;
+  if (!this.y6m_1.equals(other.y6m_1))
+    return false;
+  return true;
+};
+function Companion_0() {
+}
+var Companion_instance_1;
+function Companion_getInstance_0() {
+  return Companion_instance_1;
+}
+function EdgeConfig(edgecasesGenerationProbability) {
+  edgecasesGenerationProbability = edgecasesGenerationProbability === VOID ? PropertyTesting_getInstance().m6n_1 : edgecasesGenerationProbability;
+  this.o6m_1 = edgecasesGenerationProbability;
+  var containsArg = this.o6m_1;
+  // Inline function 'kotlin.check' call
+  if (!(0.0 <= containsArg ? containsArg <= 1.0 : false)) {
+    var message = 'provided edgecasesProbability ' + this.o6m_1 + ' is not between 0.0 and 1.0';
+    throw IllegalStateException_init_$Create$(toString(message));
+  }
+}
+protoOf(EdgeConfig).toString = function () {
+  return 'EdgeConfig(edgecasesGenerationProbability=' + this.o6m_1 + ')';
+};
+protoOf(EdgeConfig).hashCode = function () {
+  return getNumberHashCode(this.o6m_1);
+};
+protoOf(EdgeConfig).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof EdgeConfig))
+    return false;
+  if (!equals(this.o6m_1, other.o6m_1))
+    return false;
+  return true;
+};
+function Exhaustive() {
+}
+protoOf(Exhaustive).v6n = function () {
+  return of(Companion_instance_0, this.s2());
+};
+function asSample(_this__u8e3s4) {
+  return new Sample(_this__u8e3s4);
+}
+function sampleOf(a, shrinker) {
+  return new Sample(a, rtree(shrinker, a));
+}
+function RTree$_init_$lambda_icbwyt() {
+  return emptyList();
+}
+function RTree(value, children) {
+  var tmp;
+  if (children === VOID) {
+    tmp = lazy(RTree$_init_$lambda_icbwyt);
+  } else {
+    tmp = children;
+  }
+  children = tmp;
+  this.w6n_1 = value;
+  this.x6n_1 = children;
+}
+protoOf(RTree).toString = function () {
+  return 'RTree(value=' + toString(this.w6n_1) + ', children=' + toString(this.x6n_1) + ')';
+};
+protoOf(RTree).hashCode = function () {
+  var result = hashCode(this.w6n_1);
+  result = imul(result, 31) + hashCode(this.x6n_1) | 0;
+  return result;
+};
+protoOf(RTree).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof RTree))
+    return false;
+  if (!equals(this.w6n_1, other.w6n_1))
+    return false;
+  if (!equals(this.x6n_1, other.x6n_1))
+    return false;
+  return true;
+};
+function bimap(_this__u8e3s4, f, g) {
+  return new bimap$1(_this__u8e3s4, f, g);
+}
+function rtree(_this__u8e3s4, value) {
+  var fn = rtree$lambda(value);
+  return rtree_0(_this__u8e3s4, fn);
+}
+function rtree_0(_this__u8e3s4, value) {
+  return new RTree(value, lazy(rtree$lambda_0(value, _this__u8e3s4)));
+}
+function map(_this__u8e3s4, f) {
+  var b = map$lambda(f, _this__u8e3s4);
+  var c = lazy(map$lambda_0(_this__u8e3s4, f));
+  return new RTree(b, c);
+}
+function bimap$1($this_bimap, $f, $g) {
+  this.y6n_1 = $this_bimap;
+  this.z6n_1 = $f;
+  this.a6o_1 = $g;
+}
+protoOf(bimap$1).b6o = function (value) {
+  var tmp0 = this.y6n_1.c6o(this.z6n_1(value));
+  // Inline function 'kotlin.collections.map' call
+  var transform = this.a6o_1;
+  // Inline function 'kotlin.collections.mapTo' call
+  var destination = ArrayList_init_$Create$(collectionSizeOrDefault(tmp0, 10));
+  var _iterator__ex2g4s = tmp0.t();
+  while (_iterator__ex2g4s.u()) {
+    var item = _iterator__ex2g4s.v();
+    destination.y(transform(item));
+  }
+  return destination;
+};
+protoOf(bimap$1).c6o = function (value) {
+  return this.b6o((value == null ? true : !(value == null)) ? value : THROW_CCE());
+};
+function rtree$lambda($value) {
+  return function () {
+    return $value;
+  };
+}
+function rtree$lambda_0($value, $this_rtree) {
+  return function () {
+    var a = $value();
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = distinct($this_rtree.c6o(a));
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      if (!equals(element, a)) {
+        destination.y(element);
+      }
+    }
+    // Inline function 'kotlin.collections.map' call
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(destination, 10));
+    var _iterator__ex2g4s_0 = destination.t();
+    while (_iterator__ex2g4s_0.u()) {
+      var item = _iterator__ex2g4s_0.v();
+      var tmp$ret$3 = rtree($this_rtree, item);
+      destination_0.y(tmp$ret$3);
+    }
+    return destination_0;
+  };
+}
+function map$lambda($f, $this_map) {
+  return function () {
+    return $f($this_map.w6n_1());
+  };
+}
+function map$lambda_0($this_map, $f) {
+  return function () {
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = $this_map.x6n_1.m1();
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var _iterator__ex2g4s = this_0.t();
+    while (_iterator__ex2g4s.u()) {
+      var item = _iterator__ex2g4s.v();
+      var tmp$ret$0 = map(item, $f);
+      destination.y(tmp$ret$0);
+    }
+    return destination;
+  };
+}
+function Off() {
+  Off_instance = this;
+  ShrinkingMode.call(this);
+}
+var Off_instance;
+function Off_getInstance() {
+  if (Off_instance == null)
+    new Off();
+  return Off_instance;
+}
+function Unbounded() {
+  Unbounded_instance = this;
+  ShrinkingMode.call(this);
+}
+var Unbounded_instance;
+function Unbounded_getInstance() {
+  if (Unbounded_instance == null)
+    new Unbounded();
+  return Unbounded_instance;
+}
+function Bounded(bound) {
+  ShrinkingMode.call(this);
+  this.d6o_1 = bound;
+}
+protoOf(Bounded).toString = function () {
+  return 'Bounded(bound=' + this.d6o_1 + ')';
+};
+protoOf(Bounded).hashCode = function () {
+  return this.d6o_1;
+};
+protoOf(Bounded).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof Bounded))
+    return false;
+  if (!(this.d6o_1 === other.d6o_1))
+    return false;
+  return true;
+};
+function ShrinkingMode() {
+}
+function next(_this__u8e3s4, rs) {
+  rs = rs === VOID ? Companion_instance_3.e6o() : rs;
+  return single(_this__u8e3s4, rs);
+}
+function single(_this__u8e3s4, rs) {
+  rs = rs === VOID ? Companion_instance_3.e6o() : rs;
+  return _this__u8e3s4.w6m(rs).x6m_1;
+}
+function boolean(_this__u8e3s4) {
+  var tmp = listOf([true, false]);
+  return arbitrary(tmp, boolean$slambda_0(null));
+}
+function boolean$slambda(resultContinuation) {
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(boolean$slambda).p6o = function ($this$arbitrary, it, $completion) {
+  var tmp = this.q6o($this$arbitrary, it, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(boolean$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.p6o(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(boolean$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      if (tmp === 0) {
+        this.e9_1 = 1;
+        return this.o6o_1.m6m_1.mi();
+      } else if (tmp === 1) {
+        throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(boolean$slambda).q6o = function ($this$arbitrary, it, completion) {
+  var i = new boolean$slambda(completion);
+  i.n6o_1 = $this$arbitrary;
+  i.o6o_1 = it;
+  return i;
+};
+function boolean$slambda_0(resultContinuation) {
+  var i = new boolean$slambda(resultContinuation);
+  var l = function ($this$arbitrary, it, $completion) {
+    return i.p6o($this$arbitrary, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function arbitrary(edgecases, fn) {
+  return new arbitrary$1(edgecases, fn);
+}
+function ArbitraryBuilderContext() {
+}
+function arbitraryBuilder(shrinker, classifier, edgecaseFn, builderFn) {
+  shrinker = shrinker === VOID ? null : shrinker;
+  classifier = classifier === VOID ? null : classifier;
+  edgecaseFn = edgecaseFn === VOID ? null : edgecaseFn;
+  return new arbitraryBuilder$1(classifier, builderFn, shrinker, edgecaseFn);
+}
+var SingleShotGenerationMode_Edgecase_instance;
+var SingleShotGenerationMode_Sample_instance;
+var SingleShotGenerationMode_entriesInitialized;
+function SingleShotGenerationMode_initEntries() {
+  if (SingleShotGenerationMode_entriesInitialized)
+    return Unit_instance;
+  SingleShotGenerationMode_entriesInitialized = true;
+  SingleShotGenerationMode_Edgecase_instance = new SingleShotGenerationMode('Edgecase', 0);
+  SingleShotGenerationMode_Sample_instance = new SingleShotGenerationMode('Sample', 1);
+}
+function SingleShotGenerationMode(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function Restricted(genMode, rs, fn) {
+  SingleShotArbContinuation.call(this, EmptyCoroutineContext_getInstance(), genMode, rs, fn);
+}
+function _get_returnedArb__lqgsvl($this) {
+  var tmp = $this.v6o_1;
+  if (!(tmp == null))
+    return tmp;
+  else {
+    throwUninitializedPropertyAccessException('returnedArb');
+  }
+}
+function SingleShotArbContinuation(context, generationMode, randomSource, fn) {
+  this.r6o_1 = context;
+  this.s6o_1 = generationMode;
+  this.t6o_1 = randomSource;
+  this.u6o_1 = fn;
+  this.w6o_1 = false;
+}
+protoOf(SingleShotArbContinuation).j9 = function () {
+  return this.r6o_1;
+};
+protoOf(SingleShotArbContinuation).x6o = function (result) {
+  this.w6o_1 = true;
+  // Inline function 'kotlin.map' call
+  var tmp;
+  if (_Result___get_isSuccess__impl__sndoy8(result)) {
+    var tmp_0 = _Result___get_value__impl__bjfvqg(result);
+    this.v6o_1 = (tmp_0 == null ? true : !(tmp_0 == null)) ? tmp_0 : THROW_CCE();
+    // Inline function 'kotlin.Companion.success' call
+    tmp = _Result___init__impl__xyqfz8(Unit_instance);
+  } else {
+    tmp = _Result___init__impl__xyqfz8(_Result___get_value__impl__bjfvqg(result));
+  }
+  // Inline function 'kotlin.getOrThrow' call
+  var this_0 = tmp;
+  throwOnFailure(this_0);
+  var tmp_1 = _Result___get_value__impl__bjfvqg(this_0);
+  if (!(tmp_1 == null ? true : !(tmp_1 == null)))
+    THROW_CCE();
+};
+protoOf(SingleShotArbContinuation).o9 = function (result) {
+  return this.x6o(result);
+};
+protoOf(SingleShotArbContinuation).y6o = function (_this__u8e3s4) {
+  // Inline function 'kotlin.require' call
+  if (!!this.w6o_1) {
+    var message = 'continuation has already been executed, if you see this error please raise a bug report';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  // Inline function 'kotlin.coroutines.intrinsics.startCoroutineUninterceptedOrReturn' call
+  var this_0 = this.u6o_1;
+  var result = startCoroutineUninterceptedOrReturnNonGeneratorVersion(this_0, _this__u8e3s4, this);
+  var tmp = this;
+  tmp.v6o_1 = result instanceof Arb ? result : THROW_CCE();
+  return _get_returnedArb__lqgsvl(this);
+};
+function Companion_1() {
+}
+protoOf(Companion_1).z6o = function (f) {
+  return new ArbitraryBuilder(f, null, null, null);
+};
+var Companion_instance_2;
+function Companion_getInstance_1() {
+  return Companion_instance_2;
+}
+function ArbitraryBuilder$withEdgecases$lambda($edgecases) {
+  return function (it) {
+    return $edgecases.r() ? null : asSample(random($edgecases, it.m6m_1));
+  };
+}
+function ArbitraryBuilder$build$1(this$0) {
+  this.c6p_1 = this$0;
+  Arb.call(this);
+  this.b6p_1 = this$0.e6p_1;
+}
+protoOf(ArbitraryBuilder$build$1).q6m = function (rs) {
+  var tmp0_safe_receiver = this.c6p_1.g6p_1;
+  return tmp0_safe_receiver == null ? null : tmp0_safe_receiver(rs);
+};
+protoOf(ArbitraryBuilder$build$1).w6m = function (rs) {
+  var sample = this.c6p_1.d6p_1(rs);
+  return this.c6p_1.f6p_1 == null ? new Sample(sample) : sampleOf(sample, this.c6p_1.f6p_1);
+};
+function ArbitraryBuilder(sampleFn, classifier, shrinker, edgecaseFn) {
+  this.d6p_1 = sampleFn;
+  this.e6p_1 = classifier;
+  this.f6p_1 = shrinker;
+  this.g6p_1 = edgecaseFn;
+}
+protoOf(ArbitraryBuilder).h6p = function (classifier) {
+  return new ArbitraryBuilder(this.d6p_1, classifier, this.f6p_1, this.g6p_1);
+};
+protoOf(ArbitraryBuilder).i6p = function (shrinker) {
+  return new ArbitraryBuilder(this.d6p_1, this.e6p_1, shrinker, this.g6p_1);
+};
+protoOf(ArbitraryBuilder).j6p = function (edgecases) {
+  return new ArbitraryBuilder(this.d6p_1, this.e6p_1, this.f6p_1, ArbitraryBuilder$withEdgecases$lambda(edgecases));
+};
+protoOf(ArbitraryBuilder).z1x = function () {
+  return new ArbitraryBuilder$build$1(this);
+};
+function arbitrary_0(edgecases, shrinker, fn) {
+  return new arbitrary$2(shrinker, edgecases, fn);
+}
+function arbitrary_1(fn) {
+  return arbitraryBuilder(VOID, VOID, VOID, arbitrary$slambda_0(fn, null));
+}
+function arbitrary_2(edgecaseFn, shrinker, sampleFn) {
+  return new arbitrary$5(shrinker, edgecaseFn, sampleFn);
+}
+function arbitrary$o$delegate$slambda($fn, resultContinuation) {
+  this.s6p_1 = $fn;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(arbitrary$o$delegate$slambda).v6p = function ($this$arbitraryBuilder, rs, $completion) {
+  var tmp = this.q6o($this$arbitraryBuilder, rs, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(arbitrary$o$delegate$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.v6p(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(arbitrary$o$delegate$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      switch (tmp) {
+        case 0:
+          this.e9_1 = 2;
+          this.d9_1 = 1;
+          suspendResult = this.s6p_1(this.t6p_1, this.u6p_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return suspendResult;
+        case 2:
+          throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.e9_1 === 2) {
+        throw e;
+      } else {
+        this.d9_1 = this.e9_1;
+        this.g9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(arbitrary$o$delegate$slambda).q6o = function ($this$arbitraryBuilder, rs, completion) {
+  var i = new arbitrary$o$delegate$slambda(this.s6p_1, completion);
+  i.t6p_1 = $this$arbitraryBuilder;
+  i.u6p_1 = rs;
+  return i;
+};
+function arbitrary$o$delegate$slambda_0($fn, resultContinuation) {
+  var i = new arbitrary$o$delegate$slambda($fn, resultContinuation);
+  var l = function ($this$arbitraryBuilder, rs, $completion) {
+    return i.v6p($this$arbitraryBuilder, rs, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function arbitrary$1($edgecases, $fn) {
+  this.y6p_1 = $edgecases;
+  Arb.call(this);
+  var tmp = this;
+  tmp.x6p_1 = arbitraryBuilder(VOID, VOID, VOID, arbitrary$o$delegate$slambda_0($fn, null));
+}
+protoOf(arbitrary$1).q6m = function (rs) {
+  return this.y6p_1.r() ? null : asSample(random(this.y6p_1, rs.m6m_1));
+};
+protoOf(arbitrary$1).w6m = function (rs) {
+  return this.x6p_1.w6m(rs);
+};
+function arbitraryBuilder$o$singleShotArb$slambda$lambda($value) {
+  return function (it) {
+    return $value;
+  };
+}
+function arbitraryBuilder$o$singleShotArb$slambda$lambda_0($edgecaseFn, $value) {
+  return function (rs) {
+    var tmp0_safe_receiver = $edgecaseFn;
+    var tmp1_elvis_lhs = tmp0_safe_receiver == null ? null : tmp0_safe_receiver(rs);
+    return tmp1_elvis_lhs == null ? asSample($value) : tmp1_elvis_lhs;
+  };
+}
+function singleShotArb($this, mode, rs) {
+  var restrictedContinuation = new Restricted(mode, rs, arbitraryBuilder$o$singleShotArb$slambda_0($this.c6q_1, rs, $this.b6q_1, $this.d6q_1, $this.e6q_1, null));
+  // Inline function 'kotlin.with' call
+  return restrictedContinuation.y6o(restrictedContinuation);
+}
+function arbitraryBuilder$o$singleShotArb$slambda($builderFn, $rs, $classifier, $shrinker, $edgecaseFn, resultContinuation) {
+  this.n6q_1 = $builderFn;
+  this.o6q_1 = $rs;
+  this.p6q_1 = $classifier;
+  this.q6q_1 = $shrinker;
+  this.r6q_1 = $edgecaseFn;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(arbitraryBuilder$o$singleShotArb$slambda).t6q = function ($this$Restricted, $completion) {
+  var tmp = this.u6q($this$Restricted, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(arbitraryBuilder$o$singleShotArb$slambda).s9 = function (p1, $completion) {
+  return this.t6q((!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE(), $completion);
+};
+protoOf(arbitraryBuilder$o$singleShotArb$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      switch (tmp) {
+        case 0:
+          this.e9_1 = 2;
+          this.d9_1 = 1;
+          suspendResult = this.n6q_1(this.s6q_1, this.o6q_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          var value = suspendResult;
+          var tmp_0 = arbitraryBuilder$o$singleShotArb$slambda$lambda(value);
+          return (new ArbitraryBuilder(tmp_0, this.p6q_1, this.q6q_1, arbitraryBuilder$o$singleShotArb$slambda$lambda_0(this.r6q_1, value))).z1x();
+        case 2:
+          throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.e9_1 === 2) {
+        throw e;
+      } else {
+        this.d9_1 = this.e9_1;
+        this.g9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(arbitraryBuilder$o$singleShotArb$slambda).u6q = function ($this$Restricted, completion) {
+  var i = new arbitraryBuilder$o$singleShotArb$slambda(this.n6q_1, this.o6q_1, this.p6q_1, this.q6q_1, this.r6q_1, completion);
+  i.s6q_1 = $this$Restricted;
+  return i;
+};
+function arbitraryBuilder$o$singleShotArb$slambda_0($builderFn, $rs, $classifier, $shrinker, $edgecaseFn, resultContinuation) {
+  var i = new arbitraryBuilder$o$singleShotArb$slambda($builderFn, $rs, $classifier, $shrinker, $edgecaseFn, resultContinuation);
+  var l = function ($this$Restricted, $completion) {
+    return i.t6q($this$Restricted, $completion);
+  };
+  l.$arity = 1;
+  return l;
+}
+function arbitraryBuilder$1($classifier, $builderFn, $shrinker, $edgecaseFn) {
+  this.b6q_1 = $classifier;
+  this.c6q_1 = $builderFn;
+  this.d6q_1 = $shrinker;
+  this.e6q_1 = $edgecaseFn;
+  Arb.call(this);
+  this.a6q_1 = $classifier;
+}
+protoOf(arbitraryBuilder$1).q6m = function (rs) {
+  return singleShotArb(this, SingleShotGenerationMode_Edgecase_getInstance(), rs).q6m(rs);
+};
+protoOf(arbitraryBuilder$1).w6m = function (rs) {
+  return singleShotArb(this, SingleShotGenerationMode_Sample_getInstance(), rs).w6m(rs);
+};
+function arbitrary$o$delegate$slambda_1($fn, resultContinuation) {
+  this.d6r_1 = $fn;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(arbitrary$o$delegate$slambda_1).v6p = function ($this$arbitraryBuilder, rs, $completion) {
+  var tmp = this.q6o($this$arbitraryBuilder, rs, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(arbitrary$o$delegate$slambda_1).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.v6p(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(arbitrary$o$delegate$slambda_1).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      switch (tmp) {
+        case 0:
+          this.e9_1 = 2;
+          this.d9_1 = 1;
+          suspendResult = this.d6r_1(this.e6r_1, this.f6r_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return suspendResult;
+        case 2:
+          throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.e9_1 === 2) {
+        throw e;
+      } else {
+        this.d9_1 = this.e9_1;
+        this.g9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(arbitrary$o$delegate$slambda_1).q6o = function ($this$arbitraryBuilder, rs, completion) {
+  var i = new arbitrary$o$delegate$slambda_1(this.d6r_1, completion);
+  i.e6r_1 = $this$arbitraryBuilder;
+  i.f6r_1 = rs;
+  return i;
+};
+function arbitrary$o$delegate$slambda_2($fn, resultContinuation) {
+  var i = new arbitrary$o$delegate$slambda_1($fn, resultContinuation);
+  var l = function ($this$arbitraryBuilder, rs, $completion) {
+    return i.v6p($this$arbitraryBuilder, rs, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function arbitrary$2($shrinker, $edgecases, $fn) {
+  this.i6r_1 = $edgecases;
+  Arb.call(this);
+  var tmp = this;
+  tmp.h6r_1 = arbitraryBuilder($shrinker, VOID, VOID, arbitrary$o$delegate$slambda_2($fn, null));
+}
+protoOf(arbitrary$2).q6m = function (rs) {
+  return this.i6r_1.r() ? null : asSample(random(this.i6r_1, rs.m6m_1));
+};
+protoOf(arbitrary$2).w6m = function (rs) {
+  return this.h6r_1.w6m(rs);
+};
+function arbitrary$slambda($fn, resultContinuation) {
+  this.r6r_1 = $fn;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(arbitrary$slambda).v6p = function ($this$arbitraryBuilder, rs, $completion) {
+  var tmp = this.q6o($this$arbitraryBuilder, rs, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(arbitrary$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.v6p(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(arbitrary$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      switch (tmp) {
+        case 0:
+          this.e9_1 = 2;
+          this.d9_1 = 1;
+          suspendResult = this.r6r_1(this.s6r_1, this.t6r_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return suspendResult;
+        case 2:
+          throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.e9_1 === 2) {
+        throw e;
+      } else {
+        this.d9_1 = this.e9_1;
+        this.g9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(arbitrary$slambda).q6o = function ($this$arbitraryBuilder, rs, completion) {
+  var i = new arbitrary$slambda(this.r6r_1, completion);
+  i.s6r_1 = $this$arbitraryBuilder;
+  i.t6r_1 = rs;
+  return i;
+};
+function arbitrary$slambda_0($fn, resultContinuation) {
+  var i = new arbitrary$slambda($fn, resultContinuation);
+  var l = function ($this$arbitraryBuilder, rs, $completion) {
+    return i.v6p($this$arbitraryBuilder, rs, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function arbitrary$o$delegate$slambda_3($sampleFn, resultContinuation) {
+  this.c6s_1 = $sampleFn;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(arbitrary$o$delegate$slambda_3).v6p = function ($this$arbitraryBuilder, rs, $completion) {
+  var tmp = this.q6o($this$arbitraryBuilder, rs, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(arbitrary$o$delegate$slambda_3).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.v6p(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(arbitrary$o$delegate$slambda_3).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      switch (tmp) {
+        case 0:
+          this.e9_1 = 2;
+          this.d9_1 = 1;
+          suspendResult = this.c6s_1(this.d6s_1, this.e6s_1, this);
+          if (suspendResult === get_COROUTINE_SUSPENDED()) {
+            return suspendResult;
+          }
+
+          continue $sm;
+        case 1:
+          return suspendResult;
+        case 2:
+          throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      if (this.e9_1 === 2) {
+        throw e;
+      } else {
+        this.d9_1 = this.e9_1;
+        this.g9_1 = e;
+      }
+    }
+   while (true);
+};
+protoOf(arbitrary$o$delegate$slambda_3).q6o = function ($this$arbitraryBuilder, rs, completion) {
+  var i = new arbitrary$o$delegate$slambda_3(this.c6s_1, completion);
+  i.d6s_1 = $this$arbitraryBuilder;
+  i.e6s_1 = rs;
+  return i;
+};
+function arbitrary$o$delegate$slambda_4($sampleFn, resultContinuation) {
+  var i = new arbitrary$o$delegate$slambda_3($sampleFn, resultContinuation);
+  var l = function ($this$arbitraryBuilder, rs, $completion) {
+    return i.v6p($this$arbitraryBuilder, rs, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function arbitrary$5($shrinker, $edgecaseFn, $sampleFn) {
+  this.h6s_1 = $edgecaseFn;
+  Arb.call(this);
+  var tmp = this;
+  tmp.g6s_1 = arbitraryBuilder($shrinker, VOID, VOID, arbitrary$o$delegate$slambda_4($sampleFn, null));
+}
+protoOf(arbitrary$5).q6m = function (rs) {
+  return this.h6s_1(rs);
+};
+protoOf(arbitrary$5).w6m = function (rs) {
+  return this.g6s_1.w6m(rs);
+};
+function SingleShotGenerationMode_Edgecase_getInstance() {
+  SingleShotGenerationMode_initEntries();
+  return SingleShotGenerationMode_Edgecase_instance;
+}
+function SingleShotGenerationMode_Sample_getInstance() {
+  SingleShotGenerationMode_initEntries();
+  return SingleShotGenerationMode_Sample_instance;
+}
+function get_ByteShrinker() {
+  _init_properties_bytes_kt__yz6anb();
+  return ByteShrinker;
+}
+var ByteShrinker;
+var UByteShrinker;
+function byteArray(_this__u8e3s4, length, content) {
+  _init_properties_bytes_kt__yz6anb();
+  // Inline function 'io.kotest.property.arbitrary.toPrimitiveArray' call
+  var tmp;
+  if (length instanceof Arb) {
+    tmp = length;
+  } else {
+    if (length instanceof Exhaustive) {
+      tmp = length.v6n();
+    } else {
+      noWhenBranchMatchedException();
+    }
+  }
+  var tmp_0 = tmp;
+  var tmp_1 = flatMap(tmp_0, byteArray$lambda(content));
+  return map_0(tmp_1, byteArray$lambda_0);
+}
+function byte(_this__u8e3s4, min, max) {
+  min = min === VOID ? -128 : min;
+  max = max === VOID ? 127 : max;
+  _init_properties_bytes_kt__yz6anb();
+  // Inline function 'kotlin.byteArrayOf' call
+  // Inline function 'kotlin.collections.filter' call
+  var tmp0 = new Int8Array([min, -1, 0, 1, max]);
+  // Inline function 'kotlin.collections.filterTo' call
+  var destination = ArrayList_init_$Create$_0();
+  var inductionVariable = 0;
+  var last = tmp0.length;
+  while (inductionVariable < last) {
+    var element = tmp0[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    // Inline function 'kotlin.ranges.contains' call
+    var this_0 = numberRangeToNumber(min, max);
+    if (contains(isInterface(this_0, ClosedRange) ? this_0 : THROW_CCE(), element)) {
+      destination.y(element);
+    }
+  }
+  var tmp = distinct(destination);
+  var tmp_0 = get_ByteShrinker();
+  return arbitrary_0(tmp, tmp_0, byte$slambda_0(min, max, null));
+}
+function ByteShrinker$lambda(it) {
+  _init_properties_bytes_kt__yz6anb();
+  return it;
+}
+function ByteShrinker$lambda_0(it) {
+  _init_properties_bytes_kt__yz6anb();
+  return toByte(it);
+}
+function UByteShrinker$lambda(it) {
+  _init_properties_bytes_kt__yz6anb();
+  // Inline function 'kotlin.UByte.toUInt' call
+  var this_0 = it.hn_1;
+  var tmp$ret$0 = _UInt___init__impl__l7qpdl(_UByte___get_data__impl__jof9qr(this_0) & 255);
+  return new UInt(tmp$ret$0);
+}
+function UByteShrinker$lambda_0(it) {
+  _init_properties_bytes_kt__yz6anb();
+  // Inline function 'kotlin.UInt.toUByte' call
+  var this_0 = it.sn_1;
+  // Inline function 'kotlin.toUByte' call
+  var this_1 = _UInt___get_data__impl__f0vqqw(this_0);
+  var tmp$ret$1 = _UByte___init__impl__g9hnc4(toByte(this_1));
+  return new UByte(tmp$ret$1);
+}
+function byteArray$lambda($generateContents) {
+  return function (length) {
+    return list(Companion_instance_0, $generateContents, numberRangeToNumber(length, length));
+  };
+}
+function byteArray$lambda_0(it) {
+  _init_properties_bytes_kt__yz6anb();
+  return toByteArray(it);
+}
+function byte$slambda$lambda($it) {
+  return function () {
+    return first($it.m6m_1.qi(1));
+  };
+}
+function byte$slambda$lambda_0($min, $max) {
+  return function (it) {
+    // Inline function 'kotlin.ranges.contains' call
+    var this_0 = numberRangeToNumber($min, $max);
+    return contains(isInterface(this_0, ClosedRange) ? this_0 : THROW_CCE(), it);
+  };
+}
+function byte$slambda($min, $max, resultContinuation) {
+  this.q6s_1 = $min;
+  this.r6s_1 = $max;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(byte$slambda).u6s = function ($this$arbitrary, it, $completion) {
+  var tmp = this.q6o($this$arbitrary, it, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(byte$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.u6s(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(byte$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      if (tmp === 0) {
+        this.e9_1 = 1;
+        var tmp_0 = generateSequence(byte$slambda$lambda(this.t6s_1));
+        return first_0(filter(tmp_0, byte$slambda$lambda_0(this.q6s_1, this.r6s_1)));
+      } else if (tmp === 1) {
+        throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(byte$slambda).q6o = function ($this$arbitrary, it, completion) {
+  var i = new byte$slambda(this.q6s_1, this.r6s_1, completion);
+  i.s6s_1 = $this$arbitrary;
+  i.t6s_1 = it;
+  return i;
+};
+function byte$slambda_0($min, $max, resultContinuation) {
+  var i = new byte$slambda($min, $max, resultContinuation);
+  var l = function ($this$arbitrary, it, $completion) {
+    return i.u6s($this$arbitrary, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var properties_initialized_bytes_kt_a5jamz;
+function _init_properties_bytes_kt__yz6anb() {
+  if (!properties_initialized_bytes_kt_a5jamz) {
+    properties_initialized_bytes_kt_a5jamz = true;
+    var tmp = new IntShrinker(numberRangeToNumber(-128, 127));
+    var tmp_0 = ByteShrinker$lambda;
+    ByteShrinker = bimap(tmp, tmp_0, ByteShrinker$lambda_0);
+    var tmp0 = _UByte___init__impl__g9hnc4(0);
+    // Inline function 'kotlin.UByte.rangeTo' call
+    var other = _UByte___init__impl__g9hnc4(-1);
+    // Inline function 'kotlin.UByte.toUInt' call
+    var tmp_1 = _UInt___init__impl__l7qpdl(_UByte___get_data__impl__jof9qr(tmp0) & 255);
+    // Inline function 'kotlin.UByte.toUInt' call
+    var tmp$ret$1 = _UInt___init__impl__l7qpdl(_UByte___get_data__impl__jof9qr(other) & 255);
+    var tmp$ret$2 = new UIntRange(tmp_1, tmp$ret$1);
+    var tmp_2 = new UIntShrinker(tmp$ret$2);
+    var tmp_3 = UByteShrinker$lambda;
+    UByteShrinker = bimap(tmp_2, tmp_3, UByteShrinker$lambda_0);
+  }
+}
+function element(_this__u8e3s4, collection) {
+  // Inline function 'kotlin.collections.isNotEmpty' call
+  // Inline function 'kotlin.require' call
+  if (!!collection.r()) {
+    var message = 'The supplied collection must not be empty.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  return arbitrary_1(element$slambda_0(collection, null));
+}
+function of(_this__u8e3s4, collection) {
+  return element(_this__u8e3s4, collection);
+}
+function element_0(_this__u8e3s4, collection) {
+  // Inline function 'kotlin.collections.isNotEmpty' call
+  // Inline function 'kotlin.collections.isEmpty' call
+  // Inline function 'kotlin.require' call
+  if (!!(collection.length === 0)) {
+    var message = 'The supplied collection must not be empty.';
+    throw IllegalArgumentException_init_$Create$(toString(message));
+  }
+  return arbitrary_1(element$slambda_2(collection, null));
+}
+function list(_this__u8e3s4, gen, range) {
+  range = range === VOID ? PropertyTesting_getInstance().u6n_1 : range;
+  // Inline function 'kotlin.check' call
+  if (!!range.r()) {
+    throw IllegalStateException_init_$Create$('Check failed.');
+  }
+  // Inline function 'kotlin.check' call
+  if (!(range.p1_1 >= 0)) {
+    throw IllegalStateException_init_$Create$('Check failed.');
+  }
+  var tmp = list$lambda(gen, range);
+  var tmp_0 = new ListShrinker(range);
+  return arbitrary_2(tmp, tmp_0, list$slambda_0(range, gen, null));
+}
+function ListShrinker(range) {
+  this.v6s_1 = range;
+}
+protoOf(ListShrinker).w6s = function (value) {
+  var tmp;
+  if (value.r()) {
+    tmp = emptyList();
+  } else if (value.b1() === 1) {
+    tmp = this.v6s_1.fj(0) ? listOf_0(emptyList()) : emptyList();
+  } else {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = listOf([take(value, 1), dropLast(value, 1), take(value, value.b1() / 2 | 0), drop(value, 1)]);
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      var progression = this.v6s_1;
+      var containsLower = progression.p1_1;
+      var containsUpper = progression.q1_1;
+      var containsArg = element.b1();
+      if (containsLower <= containsArg ? containsArg <= containsUpper : false) {
+        destination.y(element);
+      }
+    }
+    tmp = destination;
+  }
+  return tmp;
+};
+protoOf(ListShrinker).c6o = function (value) {
+  return this.w6s((!(value == null) ? isInterface(value, KtList) : false) ? value : THROW_CCE());
+};
+function element$slambda($collection, resultContinuation) {
+  this.f6t_1 = $collection;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(element$slambda).i6t = function ($this$arbitrary, it, $completion) {
+  var tmp = this.q6o($this$arbitrary, it, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(element$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.i6t(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(element$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      if (tmp === 0) {
+        this.e9_1 = 1;
+        return random(this.f6t_1, this.h6t_1.m6m_1);
+      } else if (tmp === 1) {
+        throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(element$slambda).q6o = function ($this$arbitrary, it, completion) {
+  var i = new element$slambda(this.f6t_1, completion);
+  i.g6t_1 = $this$arbitrary;
+  i.h6t_1 = it;
+  return i;
+};
+function element$slambda_0($collection, resultContinuation) {
+  var i = new element$slambda($collection, resultContinuation);
+  var l = function ($this$arbitrary, it, $completion) {
+    return i.i6t($this$arbitrary, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function element$slambda_1($collection, resultContinuation) {
+  this.r6t_1 = $collection;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(element$slambda_1).i6t = function ($this$arbitrary, it, $completion) {
+  var tmp = this.q6o($this$arbitrary, it, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(element$slambda_1).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.i6t(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(element$slambda_1).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      if (tmp === 0) {
+        this.e9_1 = 1;
+        return random_0(this.r6t_1, this.t6t_1.m6m_1);
+      } else if (tmp === 1) {
+        throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(element$slambda_1).q6o = function ($this$arbitrary, it, completion) {
+  var i = new element$slambda_1(this.r6t_1, completion);
+  i.s6t_1 = $this$arbitrary;
+  i.t6t_1 = it;
+  return i;
+};
+function element$slambda_2($collection, resultContinuation) {
+  var i = new element$slambda_1($collection, resultContinuation);
+  var l = function ($this$arbitrary, it, $completion) {
+    return i.i6t($this$arbitrary, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function list$lambda($gen, $range) {
+  return function (rs) {
+    var emptyList_0 = emptyList();
+    var tmp0_subject = $gen;
+    var tmp;
+    if (tmp0_subject instanceof Arb) {
+      var tmp1_elvis_lhs = $gen.q6m(rs);
+      tmp = listOf_0((tmp1_elvis_lhs == null ? $gen.w6m(rs) : tmp1_elvis_lhs).x6m_1);
+    } else {
+      if (tmp0_subject instanceof Exhaustive) {
+        var tmp2_safe_receiver = firstOrNull($gen.s2());
+        var tmp_0;
+        if (tmp2_safe_receiver == null) {
+          tmp_0 = null;
+        } else {
+          // Inline function 'kotlin.let' call
+          tmp_0 = listOf_0(tmp2_safe_receiver);
+        }
+        tmp = tmp_0;
+      } else {
+        noWhenBranchMatchedException();
+      }
+    }
+    var singleList = tmp;
+    var tmp_1;
+    if ($range.q1_1 < 2) {
+      tmp_1 = null;
+    } else {
+      if ($gen instanceof Arb) {
+        // Inline function 'kotlin.math.max' call
+        var b = $range.p1_1;
+        // Inline function 'kotlin.collections.List' call
+        // Inline function 'kotlin.collections.MutableList' call
+        var size = Math.max(2, b);
+        var list = ArrayList_init_$Create$(size);
+        // Inline function 'kotlin.repeat' call
+        var inductionVariable = 0;
+        if (inductionVariable < size)
+          do {
+            var index = inductionVariable;
+            inductionVariable = inductionVariable + 1 | 0;
+            var tmp0_elvis_lhs = $gen.q6m(rs);
+            var tmp$ret$3 = (tmp0_elvis_lhs == null ? $gen.w6m(rs) : tmp0_elvis_lhs).x6m_1;
+            list.y(tmp$ret$3);
+          }
+           while (inductionVariable < size);
+        tmp_1 = list;
+      } else {
+        if ($gen instanceof Exhaustive) {
+          var tmp3_safe_receiver = firstOrNull($gen.s2());
+          var tmp_2;
+          if (tmp3_safe_receiver == null) {
+            tmp_2 = null;
+          } else {
+            // Inline function 'kotlin.let' call
+            // Inline function 'kotlin.math.max' call
+            var b_0 = $range.p1_1;
+            // Inline function 'kotlin.collections.List' call
+            // Inline function 'kotlin.collections.MutableList' call
+            var size_0 = Math.max(2, b_0);
+            var list_0 = ArrayList_init_$Create$(size_0);
+            // Inline function 'kotlin.repeat' call
+            var inductionVariable_0 = 0;
+            if (inductionVariable_0 < size_0)
+              do {
+                var index_0 = inductionVariable_0;
+                inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                list_0.y(tmp3_safe_receiver);
+              }
+               while (inductionVariable_0 < size_0);
+            tmp_2 = list_0;
+          }
+          tmp_1 = tmp_2;
+        } else {
+          tmp_1 = null;
+        }
+      }
+    }
+    var repeatedList = tmp_1;
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = listOfNotNull([emptyList_0, singleList, repeatedList]);
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      var containsLower = $range.p1_1;
+      var containsUpper = $range.q1_1;
+      var containsArg = element.b1();
+      if (containsLower <= containsArg ? containsArg <= containsUpper : false) {
+        destination.y(element);
+      }
+    }
+    // Inline function 'kotlin.takeIf' call
+    var tmp_3;
+    // Inline function 'kotlin.collections.isNotEmpty' call
+    if (!destination.r()) {
+      tmp_3 = destination;
+    } else {
+      tmp_3 = null;
+    }
+    var tmp4_safe_receiver = tmp_3;
+    var tmp5_safe_receiver = tmp4_safe_receiver == null ? null : distinct(tmp4_safe_receiver);
+    var tmp6_safe_receiver = tmp5_safe_receiver == null ? null : random(tmp5_safe_receiver, rs.m6m_1);
+    return tmp6_safe_receiver == null ? null : asSample(tmp6_safe_receiver);
+  };
+}
+function list$slambda($range, $gen, resultContinuation) {
+  this.c6u_1 = $range;
+  this.d6u_1 = $gen;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(list$slambda).g6u = function ($this$arbitrary, rs, $completion) {
+  var tmp = this.q6o($this$arbitrary, rs, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(list$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.g6u(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(list$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      if (tmp === 0) {
+        this.e9_1 = 1;
+        var targetSize = nextInt(this.f6u_1.m6m_1, this.c6u_1);
+        var this_0 = toList(take_0(this.d6u_1.v6m(this.f6u_1), targetSize));
+        var destination = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+        var _iterator__ex2g4s = this_0.t();
+        while (_iterator__ex2g4s.u()) {
+          var item = _iterator__ex2g4s.v();
+          destination.y(item.x6m_1);
+        }
+        return destination;
+      } else if (tmp === 1) {
+        throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(list$slambda).q6o = function ($this$arbitrary, rs, completion) {
+  var i = new list$slambda(this.c6u_1, this.d6u_1, completion);
+  i.e6u_1 = $this$arbitrary;
+  i.f6u_1 = rs;
+  return i;
+};
+function list$slambda_0($range, $gen, resultContinuation) {
+  var i = new list$slambda($range, $gen, resultContinuation);
+  var l = function ($this$arbitrary, rs, $completion) {
+    return i.g6u($this$arbitrary, rs, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+function constant(_this__u8e3s4, a) {
+  return element_0(_this__u8e3s4, [a]);
+}
+function get_numericEdgeCases() {
+  _init_properties_doubles_kt__m69t1s();
+  return numericEdgeCases;
+}
+var numericEdgeCases;
+function double(_this__u8e3s4, min, max, includeNaNs) {
+  min = min === VOID ? -1.7976931348623157E308 : min;
+  max = max === VOID ? 1.7976931348623157E308 : max;
+  includeNaNs = includeNaNs === VOID ? true : includeNaNs;
+  _init_properties_doubles_kt__m69t1s();
+  return double_0(_this__u8e3s4, rangeTo(min, max), includeNaNs);
+}
+function double_0(_this__u8e3s4, range, includeNaNs) {
+  range = range === VOID ? rangeTo(-1.7976931348623157E308, 1.7976931348623157E308) : range;
+  includeNaNs = includeNaNs === VOID ? true : includeNaNs;
+  _init_properties_doubles_kt__m69t1s();
+  // Inline function 'kotlin.collections.filter' call
+  var tmp0 = get_numericEdgeCases();
+  // Inline function 'kotlin.collections.filterTo' call
+  var destination = ArrayList_init_$Create$_0();
+  var _iterator__ex2g4s = tmp0.t();
+  while (_iterator__ex2g4s.u()) {
+    var element = _iterator__ex2g4s.v();
+    if (range.s1(element)) {
+      destination.y(element);
+    }
+  }
+  var tmp = plus(distinct(plus(destination, listOf([range.yc(), range.zc()]))), getNonFiniteEdgeCases(range, includeNaNs));
+  var tmp_0 = DoubleShrinker_getInstance();
+  return arbitrary_0(tmp, tmp_0, double$slambda_0(range, null));
+}
+function getNonFiniteEdgeCases(range, includeNaNs) {
+  _init_properties_doubles_kt__m69t1s();
+  var tmp;
+  if (includeNaNs) {
+    // Inline function 'kotlin.collections.buildList' call
+    // Inline function 'kotlin.collections.buildListInternal' call
+    // Inline function 'kotlin.apply' call
+    var this_0 = ArrayList_init_$Create$_0();
+    this_0.y(NaN);
+    if (range.yc() === -Infinity) {
+      this_0.y(-Infinity);
+    }
+    if (range.zc() === Infinity) {
+      this_0.y(Infinity);
+    }
+    tmp = this_0.p5();
+  } else {
+    tmp = emptyList();
+  }
+  return tmp;
+}
+function DoubleShrinker() {
+  DoubleShrinker_instance = this;
+  this.h6u_1 = Regex_init_$Create$('([+-]|)([0-9]*)(\\.[0-9]*|)(e[+-]?[0-9]+|)', RegexOption_IGNORE_CASE_getInstance());
+}
+protoOf(DoubleShrinker).i6u = function (value) {
+  var tmp;
+  var tmp_0;
+  if (value === 0.0 || !isFinite(value)) {
+    tmp_0 = true;
+  } else {
+    // Inline function 'kotlin.math.absoluteValue' call
+    tmp_0 = Math.abs(value) < 10 * 4.9E-324;
+  }
+  if (tmp_0) {
+    tmp = emptyList();
+  } else {
+    var tmp0_safe_receiver = this.j6u(value.toString());
+    tmp = listOfNotNull_0(tmp0_safe_receiver == null ? null : toDouble(tmp0_safe_receiver));
+  }
+  return tmp;
+};
+protoOf(DoubleShrinker).c6o = function (value) {
+  return this.i6u((!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+};
+protoOf(DoubleShrinker).j6u = function (value) {
+  var tmp0_elvis_lhs = this.h6u_1.uc(value);
+  var tmp;
+  if (tmp0_elvis_lhs == null) {
+    return null;
+  } else {
+    tmp = tmp0_elvis_lhs;
+  }
+  var matches = tmp;
+  var parts = drop(matches.rd(), 1);
+  // Inline function 'kotlin.collections.component1' call
+  var signPart = parts.c1(0);
+  // Inline function 'kotlin.collections.component2' call
+  var intPart = parts.c1(1);
+  // Inline function 'kotlin.collections.component3' call
+  var fracPart_ = parts.c1(2);
+  // Inline function 'kotlin.collections.component4' call
+  var expPart = parts.c1(3);
+  // Inline function 'kotlin.text.trimEnd' call
+  var tmp0 = isCharSequence(fracPart_) ? fracPart_ : THROW_CCE();
+  var tmp$ret$5;
+  $l$block: {
+    // Inline function 'kotlin.text.trimEnd' call
+    var inductionVariable = charSequenceLength(tmp0) - 1 | 0;
+    if (0 <= inductionVariable)
+      do {
+        var index = inductionVariable;
+        inductionVariable = inductionVariable + -1 | 0;
+        if (!(charSequenceGet(tmp0, index) === _Char___init__impl__6a9atx(48))) {
+          tmp$ret$5 = charSequenceSubSequence(tmp0, 0, index + 1 | 0);
+          break $l$block;
+        }
+      }
+       while (0 <= inductionVariable);
+    tmp$ret$5 = '';
+  }
+  var fracPart = toString(tmp$ret$5);
+  var tmp_0;
+  var tmp_1;
+  // Inline function 'kotlin.text.isNotEmpty' call
+  if (charSequenceLength(fracPart) > 0) {
+    tmp_1 = isDigit(last(fracPart));
+  } else {
+    tmp_1 = false;
+  }
+  if (tmp_1) {
+    tmp_0 = intPart + dropLast_0(fracPart, 1);
+  } else {
+    var length = intPart.length;
+    var tmp$ret$9;
+    $l$block_0: {
+      // Inline function 'kotlin.text.indexOfLast' call
+      var inductionVariable_0 = charSequenceLength(intPart) - 1 | 0;
+      if (0 <= inductionVariable_0)
+        do {
+          var index_0 = inductionVariable_0;
+          inductionVariable_0 = inductionVariable_0 + -1 | 0;
+          if (!(charSequenceGet(intPart, index_0) === _Char___init__impl__6a9atx(48))) {
+            tmp$ret$9 = index_0;
+            break $l$block_0;
+          }
+        }
+         while (0 <= inductionVariable_0);
+      tmp$ret$9 = -1;
+    }
+    // Inline function 'kotlin.let' call
+    var it = tmp$ret$9;
+    var index_1 = it === -1 ? length : it;
+    if (index_1 === 0) {
+      return null;
+    }
+    var head = take_1(intPart, index_1);
+    var tail = takeLast(intPart, (length - index_1 | 0) - 1 | 0);
+    tmp_0 = head + '0' + tail;
+  }
+  var numberPart = tmp_0;
+  return signPart + numberPart + expPart;
+};
+var DoubleShrinker_instance;
+function DoubleShrinker_getInstance() {
+  if (DoubleShrinker_instance == null)
+    new DoubleShrinker();
+  return DoubleShrinker_instance;
+}
+function double$slambda($range, resultContinuation) {
+  this.s6u_1 = $range;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(double$slambda).v6u = function ($this$arbitrary, it, $completion) {
+  var tmp = this.q6o($this$arbitrary, it, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(double$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.v6u(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(double$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      if (tmp === 0) {
+        this.e9_1 = 1;
+        return this.u6u_1.m6m_1.oi(this.s6u_1.yc(), this.s6u_1.zc());
+      } else if (tmp === 1) {
+        throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(double$slambda).q6o = function ($this$arbitrary, it, completion) {
+  var i = new double$slambda(this.s6u_1, completion);
+  i.t6u_1 = $this$arbitrary;
+  i.u6u_1 = it;
+  return i;
+};
+function double$slambda_0($range, resultContinuation) {
+  var i = new double$slambda($range, resultContinuation);
+  var l = function ($this$arbitrary, it, $completion) {
+    return i.v6u($this$arbitrary, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var properties_initialized_doubles_kt_z3lcoe;
+function _init_properties_doubles_kt__m69t1s() {
+  if (!properties_initialized_doubles_kt_z3lcoe) {
+    properties_initialized_doubles_kt_z3lcoe = true;
+    numericEdgeCases = listOf([-1.0, -4.9E-324, -0.0, 0.0, 4.9E-324, 1.0]);
+  }
+}
+function get_numericEdgeCases_0() {
+  _init_properties_floats_kt__ddosbb();
+  return numericEdgeCases_0;
+}
+var numericEdgeCases_0;
+function float(_this__u8e3s4, min, max, includeNaNs) {
+  min = min === VOID ? -3.4028235E38 : min;
+  max = max === VOID ? 3.4028235E38 : max;
+  includeNaNs = includeNaNs === VOID ? true : includeNaNs;
+  _init_properties_floats_kt__ddosbb();
+  return float_0(_this__u8e3s4, rangeTo_0(min, max), includeNaNs);
+}
+function float_0(_this__u8e3s4, range, includeNaNs) {
+  range = range === VOID ? rangeTo_0(-3.4028235E38, 3.4028235E38) : range;
+  includeNaNs = includeNaNs === VOID ? true : includeNaNs;
+  _init_properties_floats_kt__ddosbb();
+  // Inline function 'kotlin.collections.filter' call
+  var tmp0 = get_numericEdgeCases_0();
+  // Inline function 'kotlin.collections.filterTo' call
+  var destination = ArrayList_init_$Create$_0();
+  var _iterator__ex2g4s = tmp0.t();
+  while (_iterator__ex2g4s.u()) {
+    var element = _iterator__ex2g4s.v();
+    if (range.s1(element)) {
+      destination.y(element);
+    }
+  }
+  var tmp = plus(distinct(plus(destination, listOf([range.yc(), range.zc()]))), getNonFiniteEdgeCases_0(range, includeNaNs));
+  var tmp_0 = FloatShrinker_instance;
+  return arbitrary_0(tmp, tmp_0, float$slambda_0(range, null));
+}
+function getNonFiniteEdgeCases_0(range, includeNaNs) {
+  _init_properties_floats_kt__ddosbb();
+  var tmp;
+  if (includeNaNs) {
+    // Inline function 'kotlin.collections.buildList' call
+    // Inline function 'kotlin.collections.buildListInternal' call
+    // Inline function 'kotlin.apply' call
+    var this_0 = ArrayList_init_$Create$_0();
+    this_0.y(NaN);
+    if (range.yc() === -Infinity) {
+      this_0.y(-Infinity);
+    }
+    if (range.zc() === Infinity) {
+      this_0.y(Infinity);
+    }
+    tmp = this_0.p5();
+  } else {
+    tmp = emptyList();
+  }
+  return tmp;
+}
+function FloatShrinker() {
+}
+protoOf(FloatShrinker).w6u = function (value) {
+  var tmp;
+  var tmp_0;
+  if (value === 0.0 || !isFinite_0(value)) {
+    tmp_0 = true;
+  } else {
+    // Inline function 'kotlin.math.absoluteValue' call
+    tmp_0 = Math.abs(value) < 10 * 1.4E-45;
+  }
+  if (tmp_0) {
+    tmp = emptyList();
+  } else {
+    var tmp0_safe_receiver = DoubleShrinker_getInstance().j6u(value.toString());
+    var tmp_1;
+    if (tmp0_safe_receiver == null) {
+      tmp_1 = null;
+    } else {
+      // Inline function 'kotlin.text.toFloat' call
+      // Inline function 'kotlin.js.unsafeCast' call
+      // Inline function 'kotlin.js.asDynamic' call
+      tmp_1 = toDouble(tmp0_safe_receiver);
+    }
+    tmp = listOfNotNull_0(tmp_1);
+  }
+  return tmp;
+};
+protoOf(FloatShrinker).c6o = function (value) {
+  return this.w6u((!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+};
+var FloatShrinker_instance;
+function FloatShrinker_getInstance() {
+  return FloatShrinker_instance;
+}
+function float$slambda($range, resultContinuation) {
+  this.f6v_1 = $range;
+  CoroutineImpl.call(this, resultContinuation);
+}
+protoOf(float$slambda).i6v = function ($this$arbitrary, it, $completion) {
+  var tmp = this.q6o($this$arbitrary, it, $completion);
+  tmp.f9_1 = Unit_instance;
+  tmp.g9_1 = null;
+  return tmp.l9();
+};
+protoOf(float$slambda).r9 = function (p1, p2, $completion) {
+  var tmp = (!(p1 == null) ? isInterface(p1, ArbitraryBuilderContext) : false) ? p1 : THROW_CCE();
+  return this.i6v(tmp, p2 instanceof RandomSource ? p2 : THROW_CCE(), $completion);
+};
+protoOf(float$slambda).l9 = function () {
+  var suspendResult = this.f9_1;
+  $sm: do
+    try {
+      var tmp = this.d9_1;
+      if (tmp === 0) {
+        this.e9_1 = 1;
+        return this.h6v_1.m6m_1.oi(this.f6v_1.yc(), this.f6v_1.zc());
+      } else if (tmp === 1) {
+        throw this.g9_1;
+      }
+    } catch ($p) {
+      var e = $p;
+      throw e;
+    }
+   while (true);
+};
+protoOf(float$slambda).q6o = function ($this$arbitrary, it, completion) {
+  var i = new float$slambda(this.f6v_1, completion);
+  i.g6v_1 = $this$arbitrary;
+  i.h6v_1 = it;
+  return i;
+};
+function float$slambda_0($range, resultContinuation) {
+  var i = new float$slambda($range, resultContinuation);
+  var l = function ($this$arbitrary, it, $completion) {
+    return i.i6v($this$arbitrary, it, $completion);
+  };
+  l.$arity = 2;
+  return l;
+}
+var properties_initialized_floats_kt_vw92e1;
+function _init_properties_floats_kt__ddosbb() {
+  if (!properties_initialized_floats_kt_vw92e1) {
+    properties_initialized_floats_kt_vw92e1 = true;
+    numericEdgeCases_0 = listOf([-1.0, -1.4E-45, -0.0, 0.0, 1.4E-45, 1.0]);
+  }
+}
+function int(_this__u8e3s4, range) {
+  range = range === VOID ? numberRangeToNumber(-2147483648, 2147483647) : range;
+  // Inline function 'kotlin.intArrayOf' call
+  // Inline function 'kotlin.collections.filter' call
+  var tmp0 = new Int32Array([range.p1_1, -1, 0, 1, range.q1_1]);
+  // Inline function 'kotlin.collections.filterTo' call
+  var destination = ArrayList_init_$Create$_0();
+  var inductionVariable = 0;
+  var last = tmp0.length;
+  while (inductionVariable < last) {
+    var element = tmp0[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    var containsLower = range.p1_1;
+    if (element <= range.q1_1 ? containsLower <= element : false) {
+      destination.y(element);
+    }
+  }
+  var edgeCases = distinct(destination);
+  var tmp = Companion_instance_2;
+  return tmp.z6o(int$lambda(range)).j6p(edgeCases).i6p(new IntShrinker(range)).h6p(IntClassifier_init_$Create$(range)).z1x();
+}
+function IntShrinker(range) {
+  this.j6v_1 = range;
+}
+protoOf(IntShrinker).k6v = function (value) {
+  var tmp;
+  switch (value) {
+    case 0:
+      tmp = emptyList();
+      break;
+    case 1:
+    case -1:
+      // Inline function 'kotlin.collections.filter' call
+
+      var tmp0 = listOf_0(0);
+      // Inline function 'kotlin.collections.filterTo' call
+
+      var destination = ArrayList_init_$Create$_0();
+      var _iterator__ex2g4s = tmp0.t();
+      while (_iterator__ex2g4s.u()) {
+        var element = _iterator__ex2g4s.v();
+        var progression = this.j6v_1;
+        var containsLower = progression.p1_1;
+        if (element <= progression.q1_1 ? containsLower <= element : false) {
+          destination.y(element);
+        }
+      }
+
+      tmp = destination;
+      break;
+    default:
+      // Inline function 'kotlin.intArrayOf' call
+
+      var a = new Int32Array([0, 1, -1, abs(value), value / 3 | 0, value / 2 | 0, imul(value, 2) / 3 | 0]);
+      // Inline function 'kotlin.collections.map' call
+
+      var this_0 = numberRangeToNumber(1, 5);
+      // Inline function 'kotlin.collections.mapTo' call
+
+      var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+      var inductionVariable = this_0.p1_1;
+      var last = this_0.q1_1;
+      if (inductionVariable <= last)
+        do {
+          var item = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          var tmp$ret$4 = value - item | 0;
+          destination_0.y(tmp$ret$4);
+        }
+         while (!(item === last));
+      // Inline function 'kotlin.collections.filter' call
+
+      var tmp0_0 = reversed(destination_0);
+      // Inline function 'kotlin.collections.filterTo' call
+
+      var destination_1 = ArrayList_init_$Create$_0();
+      var _iterator__ex2g4s_0 = tmp0_0.t();
+      while (_iterator__ex2g4s_0.u()) {
+        var element_0 = _iterator__ex2g4s_0.v();
+        if (element_0 > 0) {
+          destination_1.y(element_0);
+        }
+      }
+
+      var b = destination_1;
+      // Inline function 'kotlin.collections.filterNot' call
+
+      var tmp0_1 = distinct_0(plus_0(a, b));
+      // Inline function 'kotlin.collections.filterNotTo' call
+
+      var destination_2 = ArrayList_init_$Create$_0();
+      var _iterator__ex2g4s_1 = tmp0_1.t();
+      while (_iterator__ex2g4s_1.u()) {
+        var element_1 = _iterator__ex2g4s_1.v();
+        if (!(element_1 === value)) {
+          destination_2.y(element_1);
+        }
+      }
+
+      // Inline function 'kotlin.collections.filter' call
+
+      // Inline function 'kotlin.collections.filterTo' call
+
+      var destination_3 = ArrayList_init_$Create$_0();
+      var _iterator__ex2g4s_2 = destination_2.t();
+      while (_iterator__ex2g4s_2.u()) {
+        var element_2 = _iterator__ex2g4s_2.v();
+        var progression_0 = this.j6v_1;
+        var containsLower_0 = progression_0.p1_1;
+        if (element_2 <= progression_0.q1_1 ? containsLower_0 <= element_2 : false) {
+          destination_3.y(element_2);
+        }
+      }
+
+      tmp = destination_3;
+      break;
+  }
+  return tmp;
+};
+protoOf(IntShrinker).c6o = function (value) {
+  return this.k6v((!(value == null) ? typeof value === 'number' : false) ? value : THROW_CCE());
+};
+function UIntShrinker(range) {
+  this.l6v_1 = range;
+}
+protoOf(UIntShrinker).m6v = function (value) {
+  var tmp;
+  if (value === _UInt___init__impl__l7qpdl(0)) {
+    tmp = emptyList();
+  } else if (value === _UInt___init__impl__l7qpdl(1)) {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = listOf_0(new UInt(_UInt___init__impl__l7qpdl(0)));
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      var it = element.sn_1;
+      var progression = this.l6v_1;
+      var containsLower = progression.eo_1;
+      if (UInt__compareTo_impl_yacclj(it, progression.fo_1) <= 0 ? 0 <= UInt__compareTo_impl_yacclj(it, containsLower) : false) {
+        destination.y(element);
+      }
+    }
+    tmp = destination;
+  } else {
+    var tmp_0 = _UInt___init__impl__l7qpdl(0);
+    var tmp_1 = _UInt___init__impl__l7qpdl(1);
+    // Inline function 'kotlin.UInt.div' call
+    var other = _UInt___init__impl__l7qpdl(3);
+    var tmp_2 = uintDivide(value, other);
+    // Inline function 'kotlin.UInt.div' call
+    var other_0 = _UInt___init__impl__l7qpdl(2);
+    var tmp_3 = uintDivide(value, other_0);
+    // Inline function 'kotlin.UInt.times' call
+    var other_1 = _UInt___init__impl__l7qpdl(2);
+    var tmp0_0 = _UInt___init__impl__l7qpdl(imul(_UInt___get_data__impl__f0vqqw(value), _UInt___get_data__impl__f0vqqw(other_1)));
+    // Inline function 'kotlin.UInt.div' call
+    var other_2 = _UInt___init__impl__l7qpdl(3);
+    var tmp$ret$6 = uintDivide(tmp0_0, other_2);
+    var a = listOf([new UInt(tmp_0), new UInt(tmp_1), new UInt(tmp_2), new UInt(tmp_3), new UInt(tmp$ret$6)]);
+    var tmp0_1 = _UInt___init__impl__l7qpdl(1);
+    // Inline function 'kotlin.UInt.rangeTo' call
+    var other_3 = _UInt___init__impl__l7qpdl(5);
+    // Inline function 'kotlin.collections.map' call
+    var this_0 = new UIntRange(tmp0_1, other_3);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_0, 10));
+    var inductionVariable = UInt__toInt_impl_93yt4d(this_0.eo_1);
+    var last = UInt__toInt_impl_93yt4d(this_0.fo_1);
+    if (UInt__compareTo_impl_yacclj(toUInt(inductionVariable), toUInt(last)) <= 0)
+      do {
+        var item = new UInt(toUInt(inductionVariable));
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.UInt.minus' call
+        var other_4 = item.sn_1;
+        var tmp$ret$8 = _UInt___init__impl__l7qpdl(_UInt___get_data__impl__f0vqqw(value) - _UInt___get_data__impl__f0vqqw(other_4) | 0);
+        var tmp$ret$9 = new UInt(tmp$ret$8);
+        destination_0.y(tmp$ret$9);
+      }
+       while (!(UInt__toInt_impl_93yt4d(item.sn_1) === last));
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_2 = reversed(destination_0);
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination_1 = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s_0 = tmp0_2.t();
+    while (_iterator__ex2g4s_0.u()) {
+      var element_0 = _iterator__ex2g4s_0.v();
+      var tmp0_3 = element_0.sn_1;
+      // Inline function 'kotlin.UInt.compareTo' call
+      var other_5 = _UInt___init__impl__l7qpdl(0);
+      if (uintCompare(_UInt___get_data__impl__f0vqqw(tmp0_3), _UInt___get_data__impl__f0vqqw(other_5)) > 0) {
+        destination_1.y(element_0);
+      }
+    }
+    var b = destination_1;
+    // Inline function 'kotlin.collections.filterNot' call
+    var tmp0_4 = distinct(plus(a, b));
+    // Inline function 'kotlin.collections.filterNotTo' call
+    var destination_2 = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s_1 = tmp0_4.t();
+    while (_iterator__ex2g4s_1.u()) {
+      var element_1 = _iterator__ex2g4s_1.v();
+      if (!(element_1.sn_1 === value)) {
+        destination_2.y(element_1);
+      }
+    }
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination_3 = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s_2 = destination_2.t();
+    while (_iterator__ex2g4s_2.u()) {
+      var element_2 = _iterator__ex2g4s_2.v();
+      var it_0 = element_2.sn_1;
+      var progression_0 = this.l6v_1;
+      var containsLower_0 = progression_0.eo_1;
+      if (UInt__compareTo_impl_yacclj(it_0, progression_0.fo_1) <= 0 ? 0 <= UInt__compareTo_impl_yacclj(it_0, containsLower_0) : false) {
+        destination_3.y(element_2);
+      }
+    }
+    tmp = destination_3;
+  }
+  return tmp;
+};
+protoOf(UIntShrinker).c6o = function (value) {
+  return this.m6v(value instanceof UInt ? value.sn_1 : THROW_CCE());
+};
+function int$lambda($range) {
+  return function (it) {
+    return nextInt(it.m6m_1, $range);
+  };
+}
+function long(_this__u8e3s4, range) {
+  range = range === VOID ? longRangeToLong(new Long(0, -2147483648), new Long(-1, 2147483647)) : range;
+  // Inline function 'kotlin.longArrayOf' call
+  // Inline function 'kotlin.collections.filter' call
+  var tmp0 = longArrayOf([range.si_1, new Long(-1, -1), new Long(0, 0), new Long(1, 0), range.ti_1]);
+  // Inline function 'kotlin.collections.filterTo' call
+  var destination = ArrayList_init_$Create$_0();
+  var inductionVariable = 0;
+  var last = tmp0.length;
+  while (inductionVariable < last) {
+    var element = tmp0[inductionVariable];
+    inductionVariable = inductionVariable + 1 | 0;
+    var containsLower = range.si_1;
+    if (compare(element, range.ti_1) <= 0 ? compare(containsLower, element) <= 0 : false) {
+      destination.y(element);
+    }
+  }
+  var edgeCases = distinct(destination);
+  var tmp = Companion_instance_2;
+  return tmp.z6o(long$lambda(range)).j6p(edgeCases).i6p(new LongShrinker(range)).h6p(LongClassifier_init_$Create$(range)).z1x();
+}
+function LongShrinker(range) {
+  this.n6v_1 = range;
+}
+protoOf(LongShrinker).o6v = function (value) {
+  var tmp;
+  if (equalsLong(value, new Long(0, 0))) {
+    tmp = emptyList();
+  } else if (equalsLong(value, new Long(1, 0)) || equalsLong(value, new Long(-1, -1))) {
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0 = listOf_0(new Long(0, 0));
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s = tmp0.t();
+    while (_iterator__ex2g4s.u()) {
+      var element = _iterator__ex2g4s.v();
+      var progression = this.n6v_1;
+      var containsLower = progression.si_1;
+      if (compare(element, progression.ti_1) <= 0 ? compare(containsLower, element) <= 0 : false) {
+        destination.y(element);
+      }
+    }
+    tmp = destination;
+  } else {
+    var tmp_0 = new Long(0, 0);
+    var tmp_1 = new Long(1, 0);
+    var tmp_2 = new Long(-1, -1);
+    var tmp_3 = abs_0(value);
+    // Inline function 'kotlin.Long.div' call
+    var tmp_4 = divide(value, fromInt(3));
+    // Inline function 'kotlin.Long.div' call
+    var tmp_5 = divide(value, fromInt(2));
+    // Inline function 'kotlin.Long.times' call
+    // Inline function 'kotlin.Long.div' call
+    var this_0 = multiply(value, fromInt(2));
+    var tmp$ret$6 = divide(this_0, fromInt(3));
+    var a = listOf([tmp_0, tmp_1, tmp_2, tmp_3, tmp_4, tmp_5, tmp$ret$6]);
+    // Inline function 'kotlin.collections.map' call
+    var this_1 = numberRangeToNumber(1, 5);
+    // Inline function 'kotlin.collections.mapTo' call
+    var destination_0 = ArrayList_init_$Create$(collectionSizeOrDefault(this_1, 10));
+    var inductionVariable = this_1.p1_1;
+    var last = this_1.q1_1;
+    if (inductionVariable <= last)
+      do {
+        var item = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.Long.minus' call
+        var other = item;
+        var tmp$ret$8 = subtract(value, fromInt(other));
+        destination_0.y(tmp$ret$8);
+      }
+       while (!(item === last));
+    // Inline function 'kotlin.collections.filter' call
+    var tmp0_0 = reversed(destination_0);
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination_1 = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s_0 = tmp0_0.t();
+    while (_iterator__ex2g4s_0.u()) {
+      var element_0 = _iterator__ex2g4s_0.v();
+      if (compare(element_0, new Long(0, 0)) > 0) {
+        destination_1.y(element_0);
+      }
+    }
+    var b = destination_1;
+    // Inline function 'kotlin.collections.filterNot' call
+    var tmp0_1 = distinct(plus(a, b));
+    // Inline function 'kotlin.collections.filterNotTo' call
+    var destination_2 = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s_1 = tmp0_1.t();
+    while (_iterator__ex2g4s_1.u()) {
+      var element_1 = _iterator__ex2g4s_1.v();
+      if (!equalsLong(element_1, value)) {
+        destination_2.y(element_1);
+      }
+    }
+    // Inline function 'kotlin.collections.filter' call
+    // Inline function 'kotlin.collections.filterTo' call
+    var destination_3 = ArrayList_init_$Create$_0();
+    var _iterator__ex2g4s_2 = destination_2.t();
+    while (_iterator__ex2g4s_2.u()) {
+      var element_2 = _iterator__ex2g4s_2.v();
+      var progression_0 = this.n6v_1;
+      var containsLower_0 = progression_0.si_1;
+      if (compare(element_2, progression_0.ti_1) <= 0 ? compare(containsLower_0, element_2) <= 0 : false) {
+        destination_3.y(element_2);
+      }
+    }
+    tmp = destination_3;
+  }
+  return tmp;
+};
+protoOf(LongShrinker).c6o = function (value) {
+  return this.o6v(value instanceof Long ? value : THROW_CCE());
+};
+function long$lambda($range) {
+  return function (it) {
+    return nextLong(it.m6m_1, $range);
+  };
+}
+function trampoline(_this__u8e3s4, next) {
+  var tmp;
+  if (_this__u8e3s4 instanceof TrampolineArb) {
+    tmp = _this__u8e3s4.s6v(next);
+  } else {
+    tmp = TrampolineArb_init_$Create$(_this__u8e3s4).s6v(next);
+  }
+  return tmp;
+}
+function TrampolineArb_init_$Init$(first, $this) {
+  TrampolineArb.call($this, first, emptyList());
+  return $this;
+}
+function TrampolineArb_init_$Create$(first) {
+  return TrampolineArb_init_$Init$(first, objectCreate(protoOf(TrampolineArb)));
+}
+function TrampolineArb(first, commands) {
+  Arb.call(this);
+  this.q6v_1 = first;
+  this.r6v_1 = commands;
+}
+protoOf(TrampolineArb).s6v = function (fn) {
+  var tmp = new TrampolineArb(this.q6v_1, plus_1(this.r6v_1, typeof fn === 'function' ? fn : THROW_CCE()));
+  return tmp instanceof TrampolineArb ? tmp : THROW_CCE();
+};
+protoOf(TrampolineArb).q6m = function (rs) {
+  var tmp0 = this.r6v_1;
+  // Inline function 'kotlin.collections.fold' call
+  var accumulator = this.q6v_1;
+  var _iterator__ex2g4s = tmp0.t();
+  while (_iterator__ex2g4s.u()) {
+    var element = _iterator__ex2g4s.v();
+    var currentArb = accumulator;
+    var tmp0_elvis_lhs = currentArb.q6m(rs);
+    var currentEdge = tmp0_elvis_lhs == null ? currentArb.w6m(rs) : tmp0_elvis_lhs;
+    var tmp = element(currentEdge instanceof Sample ? currentEdge : THROW_CCE());
+    accumulator = tmp instanceof Arb ? tmp : THROW_CCE();
+  }
+  return accumulator.q6m(rs);
+};
+protoOf(TrampolineArb).w6m = function (rs) {
+  var tmp0 = this.r6v_1;
+  var tmp = this.q6v_1;
+  // Inline function 'kotlin.collections.fold' call
+  var accumulator = tmp instanceof Arb ? tmp : THROW_CCE();
+  var _iterator__ex2g4s = tmp0.t();
+  while (_iterator__ex2g4s.u()) {
+    var element = _iterator__ex2g4s.v();
+    accumulator = element(accumulator.w6m(rs));
+  }
+  var tmp_0 = accumulator.w6m(rs);
+  return tmp_0 instanceof Sample ? tmp_0 : THROW_CCE();
+};
+function map_0(_this__u8e3s4, fn) {
+  return trampoline(_this__u8e3s4, map$lambda_1(fn));
+}
+function flatMap(_this__u8e3s4, fn) {
+  return trampoline(_this__u8e3s4, flatMap$lambda(fn));
+}
+function map$2$1($fn, $sampleA) {
+  this.u6v_1 = $fn;
+  this.v6v_1 = $sampleA;
+  Arb.call(this);
+}
+protoOf(map$2$1).q6m = function (rs) {
+  return asSample(this.u6v_1(this.v6v_1.x6m_1));
+};
+protoOf(map$2$1).w6m = function (rs) {
+  var value = this.u6v_1(this.v6v_1.x6m_1);
+  var shrinks = map(this.v6v_1.y6m_1, this.u6v_1);
+  return new Sample(value, shrinks);
+};
+function map$lambda_1($fn) {
+  return function (sampleA) {
+    return new map$2$1($fn, sampleA);
+  };
+}
+function flatMap$lambda($fn) {
+  return function (it) {
+    return $fn(it.x6m_1);
+  };
+}
+function IntClassifier_init_$Init$(range, $this) {
+  IntClassifier.call($this, range.p1_1, range.q1_1);
+  return $this;
+}
+function IntClassifier_init_$Create$(range) {
+  return IntClassifier_init_$Init$(range, objectCreate(protoOf(IntClassifier)));
+}
+function IntClassifier(min, max) {
+  this.w6v_1 = min;
+  this.x6v_1 = max;
+}
+function LongClassifier_init_$Init$(range, $this) {
+  LongClassifier.call($this, range.si_1, range.ti_1);
+  return $this;
+}
+function LongClassifier_init_$Create$(range) {
+  return LongClassifier_init_$Init$(range, objectCreate(protoOf(LongClassifier)));
+}
+function LongClassifier(min, max) {
+  this.y6v_1 = min;
+  this.z6v_1 = max;
+}
+function default_0(_this__u8e3s4) {
+  return new EdgeConfig(PropertyTesting_getInstance().m6n_1);
+}
+function PropertyTesting$defaultSeed$lambda(it) {
+  return toLong(it);
+}
+function PropertyTesting() {
+  PropertyTesting_instance = this;
+  this.z6m_1 = 10;
+  this.a6n_1 = sysprop('kotest.proptest.output.shrink-steps', true);
+  this.b6n_1 = sysprop('kotest.proptest.output.generated-values', false);
+  this.c6n_1 = sysprop('kotest.proptest.output.config', false);
+  this.d6n_1 = sysprop_0('kotest.proptest.arb.edgecases-bind-determinism', 0.9);
+  this.e6n_1 = sysprop_1('kotest.proptest.max.discard.percentage', 20);
+  this.f6n_1 = sysprop_1('kotest.proptest.discard.threshold', 50);
+  var tmp = this;
+  tmp.g6n_1 = sysprop_2('kotest.proptest.default.seed', null, PropertyTesting$defaultSeed$lambda);
+  this.h6n_1 = sysprop_1('kotest.proptest.default.min-success', 2147483647);
+  this.i6n_1 = sysprop_1('kotest.proptest.default.max-failure', 0);
+  this.j6n_1 = sysprop_1('kotest.proptest.default.iteration.count', 1000);
+  var tmp_0 = this;
+  var mode = sysprop_3('kotest.proptest.default.shrinking.mode', 'bounded');
+  var tmp_1;
+  switch (mode) {
+    case 'off':
+      tmp_1 = Off_getInstance();
+      break;
+    case 'bounded':
+      tmp_1 = new Bounded(sysprop_1('kotest.proptest.default.shrinking.bound', 1000));
+      break;
+    case 'unbounded':
+      tmp_1 = Unbounded_getInstance();
+      break;
+    default:
+      var message = 'Invalid shrinking mode: ' + mode;
+      throw IllegalStateException_init_$Create$(toString(message));
+  }
+  tmp_0.k6n_1 = tmp_1;
+  var tmp_2 = this;
+  // Inline function 'kotlin.collections.listOf' call
+  tmp_2.l6n_1 = emptyList();
+  this.m6n_1 = sysprop_0('kotest.proptest.arb.edgecases-generation-probability', 0.02);
+  this.n6n_1 = sysprop('kotest.proptest.arb.output.classifications', false);
+  this.o6n_1 = sysprop('kotest.proptest.seed.fail-if-set', false);
+  this.p6n_1 = sysprop('kotest.proptest.seed.write-failed', true);
+  this.q6n_1 = LabelOrder_Quantity_getInstance();
+  this.r6n_1 = DefaultStatisticsReporter_instance;
+  this.s6n_1 = StatisticsReportMode_ON_getInstance();
+  this.t6n_1 = sysprop('kotest.proptest.arb.string.output-hex-for-unprintable-chars', false);
+  this.u6n_1 = numberRangeToNumber(0, 100);
+}
+var PropertyTesting_instance;
+function PropertyTesting_getInstance() {
+  if (PropertyTesting_instance == null)
+    new PropertyTesting();
+  return PropertyTesting_instance;
+}
+var LabelOrder_Quantity_instance;
+var LabelOrder_Lexicographic_instance;
+var LabelOrder_entriesInitialized;
+function LabelOrder_initEntries() {
+  if (LabelOrder_entriesInitialized)
+    return Unit_instance;
+  LabelOrder_entriesInitialized = true;
+  LabelOrder_Quantity_instance = new LabelOrder('Quantity', 0);
+  LabelOrder_Lexicographic_instance = new LabelOrder('Lexicographic', 1);
+}
+function LabelOrder(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function LabelOrder_Quantity_getInstance() {
+  LabelOrder_initEntries();
+  return LabelOrder_Quantity_instance;
+}
+function Companion_2() {
+}
+protoOf(Companion_2).a6w = function (seed) {
+  return new RandomSource(Random(seed), seed);
+};
+protoOf(Companion_2).e6o = function () {
+  var seed = Default_getInstance().yf();
+  return new RandomSource(Random(seed), seed);
+};
+var Companion_instance_3;
+function Companion_getInstance_2() {
+  return Companion_instance_3;
+}
+function RandomSource(random, seed) {
+  this.m6m_1 = random;
+  this.n6m_1 = seed;
+}
+protoOf(RandomSource).toString = function () {
+  return 'RandomSource(random=' + toString(this.m6m_1) + ', seed=' + this.n6m_1.toString() + ')';
+};
+protoOf(RandomSource).hashCode = function () {
+  var result = hashCode(this.m6m_1);
+  result = imul(result, 31) + this.n6m_1.hashCode() | 0;
+  return result;
+};
+protoOf(RandomSource).equals = function (other) {
+  if (this === other)
+    return true;
+  if (!(other instanceof RandomSource))
+    return false;
+  if (!equals(this.m6m_1, other.m6m_1))
+    return false;
+  if (!equalsLong(this.n6m_1, other.n6m_1))
+    return false;
+  return true;
+};
+var StatisticsReportMode_ON_instance;
+var StatisticsReportMode_FAILED_instance;
+var StatisticsReportMode_SUCCESS_instance;
+var StatisticsReportMode_OFF_instance;
+var StatisticsReportMode_entriesInitialized;
+function StatisticsReportMode_initEntries() {
+  if (StatisticsReportMode_entriesInitialized)
+    return Unit_instance;
+  StatisticsReportMode_entriesInitialized = true;
+  StatisticsReportMode_ON_instance = new StatisticsReportMode('ON', 0);
+  StatisticsReportMode_FAILED_instance = new StatisticsReportMode('FAILED', 1);
+  StatisticsReportMode_SUCCESS_instance = new StatisticsReportMode('SUCCESS', 2);
+  StatisticsReportMode_OFF_instance = new StatisticsReportMode('OFF', 3);
+}
+function StatisticsReportMode(name, ordinal) {
+  Enum.call(this, name, ordinal);
+}
+function StatisticsReportMode_ON_getInstance() {
+  StatisticsReportMode_initEntries();
+  return StatisticsReportMode_ON_instance;
+}
+function DefaultStatisticsReporter() {
+}
+var DefaultStatisticsReporter_instance;
+function DefaultStatisticsReporter_getInstance() {
+  return DefaultStatisticsReporter_instance;
+}
+//region block: init
+Companion_instance_0 = new Companion();
+Companion_instance_1 = new Companion_0();
+Companion_instance_2 = new Companion_1();
+FloatShrinker_instance = new FloatShrinker();
+Companion_instance_3 = new Companion_2();
+DefaultStatisticsReporter_instance = new DefaultStatisticsReporter();
+//endregion
+//region block: exports
+export {
+  Companion_instance_0 as Companion_instance21ufaak2k5re2,
+  Companion_instance_3 as Companion_instance3s3n1oxamd1r4,
+  boolean as boolean22whamdaxmlpn,
+  byteArray as byteArray2qqx36w76cyb0,
+  byte as byte3rz7pgzhi6m64,
+  constant as constant1b2155qu9msbe,
+  double as doubletnd0mywl30ny,
+  element as element2c9vnyy5405af,
+  float as float3e4skrs0ychqj,
+  int as int2h4godnt2s0rr,
+  long as long1rc5doehwhlin,
+  next as next3ubxtqgi6adv7,
+};
+//endregion
+
+//# sourceMappingURL=kotest-kotest-property.mjs.map