@glandais/vcyclist-engine 0.0.0

package/vcyclist-engine.js

@@ -0,0 +1,3284 @@
+(function (factory) {
+  if (typeof define === 'function' && define.amd)
+    define(['exports', './kotlin-kotlin-stdlib.js', './vcyclist-elevation.js', './xmlutil-core.js', './kotlinx-coroutines-core.js'], factory);
+  else if (typeof exports === 'object')
+    factory(module.exports, require('./kotlin-kotlin-stdlib.js'), require('./vcyclist-elevation.js'), require('./xmlutil-core.js'), require('./kotlinx-coroutines-core.js'));
+  else {
+    if (typeof globalThis['kotlin-kotlin-stdlib'] === 'undefined') {
+      throw new Error("Error loading module 'io.github.glandais:engine'. Its dependency 'kotlin-kotlin-stdlib' was not found. Please, check whether 'kotlin-kotlin-stdlib' is loaded prior to 'io.github.glandais:engine'.");
+    }
+    if (typeof globalThis['vcyclist-elevation'] === 'undefined') {
+      throw new Error("Error loading module 'io.github.glandais:engine'. Its dependency 'vcyclist-elevation' was not found. Please, check whether 'vcyclist-elevation' is loaded prior to 'io.github.glandais:engine'.");
+    }
+    if (typeof globalThis['xmlutil-core'] === 'undefined') {
+      throw new Error("Error loading module 'io.github.glandais:engine'. Its dependency 'xmlutil-core' was not found. Please, check whether 'xmlutil-core' is loaded prior to 'io.github.glandais:engine'.");
+    }
+    if (typeof globalThis['kotlinx-coroutines-core'] === 'undefined') {
+      throw new Error("Error loading module 'io.github.glandais:engine'. Its dependency 'kotlinx-coroutines-core' was not found. Please, check whether 'kotlinx-coroutines-core' is loaded prior to 'io.github.glandais:engine'.");
+    }
+    globalThis['io.github.glandais:engine'] = factory(typeof globalThis['io.github.glandais:engine'] === 'undefined' ? {} : globalThis['io.github.glandais:engine'], globalThis['kotlin-kotlin-stdlib'], globalThis['vcyclist-elevation'], globalThis['xmlutil-core'], globalThis['kotlinx-coroutines-core']);
+  }
+}(function (_, kotlin_kotlin, kotlin_io_github_glandais_elevation, kotlin_io_github_pdvrieze_xmlutil_core, kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core) {
+  'use strict';
+  //region block: imports
+  var imul = Math.imul;
+  var protoOf = kotlin_kotlin.$_$.e5;
+  var initMetadataForCompanion = kotlin_kotlin.$_$.t4;
+  var VOID = kotlin_kotlin.$_$.a;
+  var getNumberHashCode = kotlin_kotlin.$_$.o4;
+  var equals = kotlin_kotlin.$_$.m4;
+  var initMetadataForClass = kotlin_kotlin.$_$.s4;
+  var toString = kotlin_kotlin.$_$.g5;
+  var hashCode = kotlin_kotlin.$_$.r4;
+  var getBooleanHashCode = kotlin_kotlin.$_$.n4;
+  var CoroutineImpl = kotlin_kotlin.$_$.m3;
+  var get_COROUTINE_SUSPENDED = kotlin_kotlin.$_$.x2;
+  var Unit_instance = kotlin_kotlin.$_$.g;
+  var initMetadataForCoroutine = kotlin_kotlin.$_$.u4;
+  var initMetadataForObject = kotlin_kotlin.$_$.y4;
+  var getStringHashCode = kotlin_kotlin.$_$.q4;
+  var toString_0 = kotlin_kotlin.$_$.z6;
+  var ArrayList_init_$Create$ = kotlin_kotlin.$_$.i;
+  var MathConstants_getInstance = kotlin_io_github_glandais_elevation.$_$.d;
+  var isNaN_0 = kotlin_kotlin.$_$.u6;
+  var numberToLong = kotlin_kotlin.$_$.a4;
+  var Long = kotlin_kotlin.$_$.k6;
+  var compare = kotlin_kotlin.$_$.t3;
+  var roundToInt = kotlin_kotlin.$_$.h5;
+  var listOf = kotlin_kotlin.$_$.p2;
+  var IllegalArgumentException_init_$Create$ = kotlin_kotlin.$_$.y;
+  var EventType_START_ELEMENT_getInstance = kotlin_io_github_pdvrieze_xmlutil_core.$_$.a;
+  var ArrayList_init_$Create$_0 = kotlin_kotlin.$_$.j;
+  var THROW_CCE = kotlin_kotlin.$_$.o6;
+  var isCharSequence = kotlin_kotlin.$_$.z4;
+  var trim = kotlin_kotlin.$_$.e6;
+  var charSequenceLength = kotlin_kotlin.$_$.j4;
+  var isBlank = kotlin_kotlin.$_$.u5;
+  var toDoubleOrNull = kotlin_kotlin.$_$.y5;
+  var numberToInt = kotlin_kotlin.$_$.c5;
+  var StringBuilder_init_$Create$ = kotlin_kotlin.$_$.s;
+  var Companion_getInstance = kotlin_kotlin.$_$.e;
+  var IllegalArgumentException = kotlin_kotlin.$_$.j6;
+  var get_xmlStreaming = kotlin_io_github_pdvrieze_xmlutil_core.$_$.e;
+  var IllegalArgumentException_init_$Create$_0 = kotlin_kotlin.$_$.z;
+  var XmlException = kotlin_io_github_pdvrieze_xmlutil_core.$_$.c;
+  var firstOrNull = kotlin_kotlin.$_$.l2;
+  var IllegalStateException_init_$Create$ = kotlin_kotlin.$_$.a1;
+  var toNumber = kotlin_kotlin.$_$.c4;
+  var XmlDeclMode_None_getInstance = kotlin_io_github_pdvrieze_xmlutil_core.$_$.b;
+  var newGenericWriter = kotlin_io_github_pdvrieze_xmlutil_core.$_$.d;
+  var LatLon = kotlin_io_github_glandais_elevation.$_$.f;
+  var ElevationSmoother_instance = kotlin_io_github_glandais_elevation.$_$.c;
+  var until = kotlin_kotlin.$_$.o5;
+  var LatLonElevation = kotlin_io_github_glandais_elevation.$_$.e;
+  var arrayCopy = kotlin_kotlin.$_$.a2;
+  var Distance_instance = kotlin_io_github_glandais_elevation.$_$.a;
+  var DouglasPeucker_instance = kotlin_io_github_glandais_elevation.$_$.b;
+  var collectionSizeOrDefault = kotlin_kotlin.$_$.c2;
+  var mapCapacity = kotlin_kotlin.$_$.r2;
+  var coerceAtLeast = kotlin_kotlin.$_$.k5;
+  var LinkedHashMap_init_$Create$ = kotlin_kotlin.$_$.m;
+  var enumEntries = kotlin_kotlin.$_$.o3;
+  var Enum = kotlin_kotlin.$_$.g6;
+  var noWhenBranchMatchedException = kotlin_kotlin.$_$.w6;
+  var LinkedHashMap_init_$Create$_0 = kotlin_kotlin.$_$.n;
+  var multiply = kotlin_kotlin.$_$.z3;
+  var subtract = kotlin_kotlin.$_$.b4;
+  var equalsLong = kotlin_kotlin.$_$.w3;
+  var add = kotlin_kotlin.$_$.s3;
+  var get_ONE = kotlin_kotlin.$_$.r3;
+  var sorted = kotlin_kotlin.$_$.t2;
+  var Default_getInstance = kotlin_kotlin.$_$.d;
+  var emptyList = kotlin_kotlin.$_$.j2;
+  var GlobalScope_instance = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.a;
+  var promise = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.j;
+  var CoroutineScope = kotlin_org_jetbrains_kotlinx_kotlinx_coroutines_core.$_$.h;
+  var isInterface = kotlin_kotlin.$_$.a5;
+  var initMetadataForLambda = kotlin_kotlin.$_$.x4;
+  //endregion
+  //region block: pre-declaration
+  initMetadataForCompanion(Companion);
+  initMetadataForClass(Bike, 'Bike', Bike);
+  initMetadataForClass(Course, 'Course');
+  initMetadataForCompanion(Companion_0);
+  initMetadataForClass(CoursePhysics, 'CoursePhysics');
+  initMetadataForCompanion(Companion_1);
+  initMetadataForClass(Cyclist, 'Cyclist', Cyclist);
+  initMetadataForClass(SimplifyPathOptions, 'SimplifyPathOptions', SimplifyPathOptions);
+  initMetadataForCompanion(Companion_2);
+  initMetadataForClass(EnhanceOptions, 'EnhanceOptions', EnhanceOptions);
+  initMetadataForCoroutine($enhanceCourseCOROUTINE$, CoroutineImpl);
+  initMetadataForObject(Enhancer, 'Enhancer', VOID, VOID, VOID, [3]);
+  initMetadataForClass(GpxDocument, 'GpxDocument');
+  initMetadataForClass(GpxTrack, 'GpxTrack');
+  initMetadataForClass(GpxTrackPoint, 'GpxTrackPoint');
+  initMetadataForClass(ExtensionsAccumulator, 'ExtensionsAccumulator', ExtensionsAccumulator);
+  initMetadataForObject(GpxParser, 'GpxParser');
+  initMetadataForObject(GpxWriter, 'GpxWriter');
+  initMetadataForCoroutine($fixElevationCOROUTINE$, CoroutineImpl);
+  initMetadataForObject(ElevationStep, 'ElevationStep', VOID, VOID, VOID, [2]);
+  initMetadataForClass(GeneratedPath, 'GeneratedPath');
+  initMetadataForCompanion(Companion_3);
+  initMetadataForClass(BoundsRad, 'BoundsRad');
+  initMetadataForCompanion(Companion_4);
+  initMetadataForClass(Path, 'Path', VOID, GeneratedPath);
+  initMetadataForObject(PathSimplifier, 'PathSimplifier');
+  initMetadataForCompanion(Companion_5);
+  initMetadataForClass(PointField, 'PointField', VOID, Enum);
+  initMetadataForClass(PointFieldCategory, 'PointFieldCategory', VOID, Enum);
+  initMetadataForClass(Copy, 'Copy');
+  initMetadataForClass(Interpolate, 'Interpolate');
+  initMetadataForObject(PointPerDistance, 'PointPerDistance');
+  initMetadataForClass(Copy_0, 'Copy');
+  initMetadataForClass(Interpolate_0, 'Interpolate');
+  initMetadataForObject(PointPerSecond, 'PointPerSecond');
+  initMetadataForObject(AeroPowerProvider, 'AeroPowerProvider');
+  initMetadataForObject(AeroProviderConstant, 'AeroProviderConstant');
+  initMetadataForCompanion(Companion_6);
+  initMetadataForClass(CyclistPowerProviderBase, 'CyclistPowerProviderBase');
+  initMetadataForObject(GravPowerProvider, 'GravPowerProvider');
+  initMetadataForClass(Harmonic, 'Harmonic');
+  initMetadataForObject(MaxSpeedComputer, 'MaxSpeedComputer');
+  initMetadataForObject(MuscularPowerProvider, 'MuscularPowerProvider');
+  initMetadataForObject(PowerComputer, 'PowerComputer');
+  initMetadataForClass(PowerProviderConstant, 'PowerProviderConstant', VOID, CyclistPowerProviderBase);
+  initMetadataForObject(RhoProviderDefault, 'RhoProviderDefault');
+  initMetadataForObject(RhoProviderEstimate, 'RhoProviderEstimate');
+  initMetadataForObject(RollingResistancePowerProvider, 'RollingResistancePowerProvider');
+  initMetadataForObject(VirtualizeService, 'VirtualizeService');
+  initMetadataForObject(WheelBearingsPowerProvider, 'WheelBearingsPowerProvider');
+  initMetadataForCompanion(Companion_7);
+  initMetadataForClass(Wind, 'Wind');
+  initMetadataForObject(WindProviderNone, 'WindProviderNone');
+  initMetadataForLambda(enhance$slambda, CoroutineImpl, VOID, [1]);
+  //endregion
+  function Companion() {
+    Companion_instance = this;
+    this.p1d_1 = new Bike();
+  }
+  var Companion_instance;
+  function Companion_getInstance_0() {
+    if (Companion_instance == null)
+      new Companion();
+    return Companion_instance;
+  }
+  function Bike(crr, inertiaFront, inertiaRear, wheelRadiusM, efficiency) {
+    Companion_getInstance_0();
+    crr = crr === VOID ? 0.004 : crr;
+    inertiaFront = inertiaFront === VOID ? 0.05 : inertiaFront;
+    inertiaRear = inertiaRear === VOID ? 0.07 : inertiaRear;
+    wheelRadiusM = wheelRadiusM === VOID ? 0.7 : wheelRadiusM;
+    efficiency = efficiency === VOID ? 0.976 : efficiency;
+    this.q1d_1 = crr;
+    this.r1d_1 = inertiaFront;
+    this.s1d_1 = inertiaRear;
+    this.t1d_1 = wheelRadiusM;
+    this.u1d_1 = efficiency;
+  }
+  protoOf(Bike).toString = function () {
+    return 'Bike(crr=' + this.q1d_1 + ', inertiaFront=' + this.r1d_1 + ', inertiaRear=' + this.s1d_1 + ', wheelRadiusM=' + this.t1d_1 + ', efficiency=' + this.u1d_1 + ')';
+  };
+  protoOf(Bike).hashCode = function () {
+    var result = getNumberHashCode(this.q1d_1);
+    result = imul(result, 31) + getNumberHashCode(this.r1d_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.s1d_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.t1d_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.u1d_1) | 0;
+    return result;
+  };
+  protoOf(Bike).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Bike))
+      return false;
+    if (!equals(this.q1d_1, other.q1d_1))
+      return false;
+    if (!equals(this.r1d_1, other.r1d_1))
+      return false;
+    if (!equals(this.s1d_1, other.s1d_1))
+      return false;
+    if (!equals(this.t1d_1, other.t1d_1))
+      return false;
+    if (!equals(this.u1d_1, other.u1d_1))
+      return false;
+    return true;
+  };
+  function Course(path, cyclist, bike) {
+    cyclist = cyclist === VOID ? Companion_getInstance_2().v1d_1 : cyclist;
+    bike = bike === VOID ? Companion_getInstance_0().p1d_1 : bike;
+    this.w1d_1 = path;
+    this.x1d_1 = cyclist;
+    this.y1d_1 = bike;
+  }
+  protoOf(Course).z1d = function (path, cyclist, bike) {
+    return new Course(path, cyclist, bike);
+  };
+  protoOf(Course).a1e = function (path, cyclist, bike, $super) {
+    path = path === VOID ? this.w1d_1 : path;
+    cyclist = cyclist === VOID ? this.x1d_1 : cyclist;
+    bike = bike === VOID ? this.y1d_1 : bike;
+    return $super === VOID ? this.z1d(path, cyclist, bike) : $super.z1d.call(this, path, cyclist, bike);
+  };
+  protoOf(Course).toString = function () {
+    return 'Course(path=' + toString(this.w1d_1) + ', cyclist=' + this.x1d_1.toString() + ', bike=' + this.y1d_1.toString() + ')';
+  };
+  protoOf(Course).hashCode = function () {
+    var result = hashCode(this.w1d_1);
+    result = imul(result, 31) + this.x1d_1.hashCode() | 0;
+    result = imul(result, 31) + this.y1d_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(Course).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Course))
+      return false;
+    if (!equals(this.w1d_1, other.w1d_1))
+      return false;
+    if (!this.x1d_1.equals(other.x1d_1))
+      return false;
+    if (!this.y1d_1.equals(other.y1d_1))
+      return false;
+    return true;
+  };
+  function Companion_0() {
+    Companion_instance_0 = this;
+    this.b1e_1 = new PowerProviderConstant(280.0);
+  }
+  var Companion_instance_0;
+  function Companion_getInstance_1() {
+    if (Companion_instance_0 == null)
+      new Companion_0();
+    return Companion_instance_0;
+  }
+  function CoursePhysics(course, rhoProvider, aeroProvider, windProvider, cyclistPowerProvider) {
+    Companion_getInstance_1();
+    rhoProvider = rhoProvider === VOID ? RhoProviderDefault_instance : rhoProvider;
+    aeroProvider = aeroProvider === VOID ? AeroProviderConstant_instance : aeroProvider;
+    windProvider = windProvider === VOID ? WindProviderNone_instance : windProvider;
+    cyclistPowerProvider = cyclistPowerProvider === VOID ? Companion_getInstance_1().b1e_1 : cyclistPowerProvider;
+    this.c1e_1 = course;
+    this.d1e_1 = rhoProvider;
+    this.e1e_1 = aeroProvider;
+    this.f1e_1 = windProvider;
+    this.g1e_1 = cyclistPowerProvider;
+  }
+  protoOf(CoursePhysics).h1e = function () {
+    return this.c1e_1.w1d_1;
+  };
+  protoOf(CoursePhysics).i1e = function () {
+    return this.c1e_1.x1d_1;
+  };
+  protoOf(CoursePhysics).j1e = function () {
+    return this.c1e_1.y1d_1;
+  };
+  protoOf(CoursePhysics).k1e = function (course, rhoProvider, aeroProvider, windProvider, cyclistPowerProvider) {
+    return new CoursePhysics(course, rhoProvider, aeroProvider, windProvider, cyclistPowerProvider);
+  };
+  protoOf(CoursePhysics).l1e = function (course, rhoProvider, aeroProvider, windProvider, cyclistPowerProvider, $super) {
+    course = course === VOID ? this.c1e_1 : course;
+    rhoProvider = rhoProvider === VOID ? this.d1e_1 : rhoProvider;
+    aeroProvider = aeroProvider === VOID ? this.e1e_1 : aeroProvider;
+    windProvider = windProvider === VOID ? this.f1e_1 : windProvider;
+    cyclistPowerProvider = cyclistPowerProvider === VOID ? this.g1e_1 : cyclistPowerProvider;
+    return $super === VOID ? this.k1e(course, rhoProvider, aeroProvider, windProvider, cyclistPowerProvider) : $super.k1e.call(this, course, rhoProvider, aeroProvider, windProvider, cyclistPowerProvider);
+  };
+  protoOf(CoursePhysics).toString = function () {
+    return 'CoursePhysics(course=' + this.c1e_1.toString() + ', rhoProvider=' + toString(this.d1e_1) + ', aeroProvider=' + toString(this.e1e_1) + ', windProvider=' + toString(this.f1e_1) + ', cyclistPowerProvider=' + toString(this.g1e_1) + ')';
+  };
+  protoOf(CoursePhysics).hashCode = function () {
+    var result = this.c1e_1.hashCode();
+    result = imul(result, 31) + hashCode(this.d1e_1) | 0;
+    result = imul(result, 31) + hashCode(this.e1e_1) | 0;
+    result = imul(result, 31) + hashCode(this.f1e_1) | 0;
+    result = imul(result, 31) + hashCode(this.g1e_1) | 0;
+    return result;
+  };
+  protoOf(CoursePhysics).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof CoursePhysics))
+      return false;
+    if (!this.c1e_1.equals(other.c1e_1))
+      return false;
+    if (!equals(this.d1e_1, other.d1e_1))
+      return false;
+    if (!equals(this.e1e_1, other.e1e_1))
+      return false;
+    if (!equals(this.f1e_1, other.f1e_1))
+      return false;
+    if (!equals(this.g1e_1, other.g1e_1))
+      return false;
+    return true;
+  };
+  function Companion_1() {
+    Companion_instance_1 = this;
+    this.v1d_1 = new Cyclist();
+  }
+  var Companion_instance_1;
+  function Companion_getInstance_2() {
+    if (Companion_instance_1 == null)
+      new Companion_1();
+    return Companion_instance_1;
+  }
+  function Cyclist(massKg, maxBrakeG, cd, frontalAreaM2, maxLeanAngleDeg, maxSpeedKmH) {
+    Companion_getInstance_2();
+    massKg = massKg === VOID ? 80.0 : massKg;
+    maxBrakeG = maxBrakeG === VOID ? 0.6 : maxBrakeG;
+    cd = cd === VOID ? 0.7 : cd;
+    frontalAreaM2 = frontalAreaM2 === VOID ? 0.5 : frontalAreaM2;
+    maxLeanAngleDeg = maxLeanAngleDeg === VOID ? 35.0 : maxLeanAngleDeg;
+    maxSpeedKmH = maxSpeedKmH === VOID ? 100.0 : maxSpeedKmH;
+    this.m1e_1 = massKg;
+    this.n1e_1 = maxBrakeG;
+    this.o1e_1 = cd;
+    this.p1e_1 = frontalAreaM2;
+    this.q1e_1 = maxLeanAngleDeg;
+    this.r1e_1 = maxSpeedKmH;
+  }
+  protoOf(Cyclist).s1e = function () {
+    // Inline function 'kotlin.math.tan' call
+    var x = this.q1e_1 * 3.141592653589793 / 180.0;
+    return Math.tan(x);
+  };
+  protoOf(Cyclist).t1e = function () {
+    return this.n1e_1 * 9.8;
+  };
+  protoOf(Cyclist).u1e = function () {
+    return this.r1e_1 / 3.6;
+  };
+  protoOf(Cyclist).toString = function () {
+    return 'Cyclist(massKg=' + this.m1e_1 + ', maxBrakeG=' + this.n1e_1 + ', cd=' + this.o1e_1 + ', frontalAreaM2=' + this.p1e_1 + ', maxLeanAngleDeg=' + this.q1e_1 + ', maxSpeedKmH=' + this.r1e_1 + ')';
+  };
+  protoOf(Cyclist).hashCode = function () {
+    var result = getNumberHashCode(this.m1e_1);
+    result = imul(result, 31) + getNumberHashCode(this.n1e_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.o1e_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.p1e_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.q1e_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.r1e_1) | 0;
+    return result;
+  };
+  protoOf(Cyclist).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Cyclist))
+      return false;
+    if (!equals(this.m1e_1, other.m1e_1))
+      return false;
+    if (!equals(this.n1e_1, other.n1e_1))
+      return false;
+    if (!equals(this.o1e_1, other.o1e_1))
+      return false;
+    if (!equals(this.p1e_1, other.p1e_1))
+      return false;
+    if (!equals(this.q1e_1, other.q1e_1))
+      return false;
+    if (!equals(this.r1e_1, other.r1e_1))
+      return false;
+    return true;
+  };
+  function SimplifyPathOptions(enabled, toleranceM, zExaggeration) {
+    enabled = enabled === VOID ? true : enabled;
+    toleranceM = toleranceM === VOID ? 10.0 : toleranceM;
+    zExaggeration = zExaggeration === VOID ? 3.0 : zExaggeration;
+    this.v1e_1 = enabled;
+    this.w1e_1 = toleranceM;
+    this.x1e_1 = zExaggeration;
+  }
+  protoOf(SimplifyPathOptions).toString = function () {
+    return 'SimplifyPathOptions(enabled=' + this.v1e_1 + ', toleranceM=' + this.w1e_1 + ', zExaggeration=' + this.x1e_1 + ')';
+  };
+  protoOf(SimplifyPathOptions).hashCode = function () {
+    var result = getBooleanHashCode(this.v1e_1);
+    result = imul(result, 31) + getNumberHashCode(this.w1e_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.x1e_1) | 0;
+    return result;
+  };
+  protoOf(SimplifyPathOptions).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof SimplifyPathOptions))
+      return false;
+    if (!(this.v1e_1 === other.v1e_1))
+      return false;
+    if (!equals(this.w1e_1, other.w1e_1))
+      return false;
+    if (!equals(this.x1e_1, other.x1e_1))
+      return false;
+    return true;
+  };
+  function Companion_2() {
+    Companion_instance_2 = this;
+    this.y1e_1 = new EnhanceOptions();
+  }
+  var Companion_instance_2;
+  function Companion_getInstance_3() {
+    if (Companion_instance_2 == null)
+      new Companion_2();
+    return Companion_instance_2;
+  }
+  function EnhanceOptions(fixElevation, computeMaxSpeeds, virtualizeTrack, computeOnePointPerSecond, simplifyPath) {
+    Companion_getInstance_3();
+    fixElevation = fixElevation === VOID ? true : fixElevation;
+    computeMaxSpeeds = computeMaxSpeeds === VOID ? true : computeMaxSpeeds;
+    virtualizeTrack = virtualizeTrack === VOID ? true : virtualizeTrack;
+    computeOnePointPerSecond = computeOnePointPerSecond === VOID ? true : computeOnePointPerSecond;
+    simplifyPath = simplifyPath === VOID ? new SimplifyPathOptions() : simplifyPath;
+    this.z1e_1 = fixElevation;
+    this.a1f_1 = computeMaxSpeeds;
+    this.b1f_1 = virtualizeTrack;
+    this.c1f_1 = computeOnePointPerSecond;
+    this.d1f_1 = simplifyPath;
+  }
+  protoOf(EnhanceOptions).toString = function () {
+    return 'EnhanceOptions(fixElevation=' + this.z1e_1 + ', computeMaxSpeeds=' + this.a1f_1 + ', virtualizeTrack=' + this.b1f_1 + ', computeOnePointPerSecond=' + this.c1f_1 + ', simplifyPath=' + this.d1f_1.toString() + ')';
+  };
+  protoOf(EnhanceOptions).hashCode = function () {
+    var result = getBooleanHashCode(this.z1e_1);
+    result = imul(result, 31) + getBooleanHashCode(this.a1f_1) | 0;
+    result = imul(result, 31) + getBooleanHashCode(this.b1f_1) | 0;
+    result = imul(result, 31) + getBooleanHashCode(this.c1f_1) | 0;
+    result = imul(result, 31) + this.d1f_1.hashCode() | 0;
+    return result;
+  };
+  protoOf(EnhanceOptions).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof EnhanceOptions))
+      return false;
+    if (!(this.z1e_1 === other.z1e_1))
+      return false;
+    if (!(this.a1f_1 === other.a1f_1))
+      return false;
+    if (!(this.b1f_1 === other.b1f_1))
+      return false;
+    if (!(this.c1f_1 === other.c1f_1))
+      return false;
+    if (!this.d1f_1.equals(other.d1f_1))
+      return false;
+    return true;
+  };
+  function $enhanceCourseCOROUTINE$(_this__u8e3s4, course, options, elevationProvider, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.m1f_1 = _this__u8e3s4;
+    this.n1f_1 = course;
+    this.o1f_1 = options;
+    this.p1f_1 = elevationProvider;
+  }
+  protoOf($enhanceCourseCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 3;
+            this.q1f_1 = this.n1f_1.h1e();
+            this.q1f_1 = PointPerDistance_instance.r1f(this.q1f_1, -1.0, 30.0);
+            if (this.o1f_1.z1e_1 && !(this.p1f_1 == null)) {
+              this.u5_1 = 1;
+              suspendResult = ElevationStep_instance.t1f(this.q1f_1, this.p1f_1, this);
+              if (suspendResult === get_COROUTINE_SUSPENDED()) {
+                return suspendResult;
+              }
+              continue $sm;
+            } else {
+              this.u5_1 = 2;
+              continue $sm;
+            }
+
+          case 1:
+            this.q1f_1 = suspendResult;
+            this.u5_1 = 2;
+            continue $sm;
+          case 2:
+            this.q1f_1 = PointPerDistance_instance.r1f(this.q1f_1, 1.0, 2.0);
+            this.q1f_1 = ElevationStep_instance.u1f(this.q1f_1);
+            var working = this.n1f_1.l1e(this.n1f_1.c1e_1.a1e(this.q1f_1));
+            if (this.o1f_1.a1f_1 || this.o1f_1.b1f_1) {
+              MaxSpeedComputer_instance.a1g(working.c1e_1);
+            }
+
+            if (this.o1f_1.b1f_1) {
+              this.q1f_1 = VirtualizeService_instance.c1g(working);
+              working = working.l1e(working.c1e_1.a1e(this.q1f_1));
+            }
+
+            if (this.o1f_1.c1f_1) {
+              this.q1f_1 = PointPerSecond_instance.d1g(this.q1f_1);
+            }
+
+            if (this.o1f_1.d1f_1.v1e_1) {
+              this.q1f_1 = PathSimplifier_instance.e1g(this.q1f_1, this.o1f_1.d1f_1.w1e_1, this.o1f_1.d1f_1.x1e_1);
+            }
+
+            return this.q1f_1;
+          case 3:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 3) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function Enhancer() {
+  }
+  protoOf(Enhancer).f1g = function (path) {
+    return new CoursePhysics(new Course(path), RhoProviderEstimate_instance, AeroProviderConstant_instance, WindProviderNone_instance, new PowerProviderConstant(280.0));
+  };
+  protoOf(Enhancer).g1g = function (path, elevationProvider, options, $completion) {
+    return this.h1g(this.f1g(path), options, elevationProvider, $completion);
+  };
+  protoOf(Enhancer).h1g = function (course, options, elevationProvider, $completion) {
+    var tmp = new $enhanceCourseCOROUTINE$(this, course, options, elevationProvider, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  var Enhancer_instance;
+  function Enhancer_getInstance() {
+    return Enhancer_instance;
+  }
+  function GpxDocument(name, tracks) {
+    name = name === VOID ? 'noname' : name;
+    this.i1g_1 = name;
+    this.j1g_1 = tracks;
+  }
+  protoOf(GpxDocument).toString = function () {
+    return 'GpxDocument(name=' + this.i1g_1 + ', tracks=' + toString(this.j1g_1) + ')';
+  };
+  protoOf(GpxDocument).hashCode = function () {
+    var result = getStringHashCode(this.i1g_1);
+    result = imul(result, 31) + hashCode(this.j1g_1) | 0;
+    return result;
+  };
+  protoOf(GpxDocument).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof GpxDocument))
+      return false;
+    if (!(this.i1g_1 === other.i1g_1))
+      return false;
+    if (!equals(this.j1g_1, other.j1g_1))
+      return false;
+    return true;
+  };
+  function GpxTrack(name, type, points) {
+    name = name === VOID ? null : name;
+    type = type === VOID ? null : type;
+    this.k1g_1 = name;
+    this.l1g_1 = type;
+    this.m1g_1 = points;
+  }
+  protoOf(GpxTrack).toString = function () {
+    return 'GpxTrack(name=' + this.k1g_1 + ', type=' + this.l1g_1 + ', points=' + toString(this.m1g_1) + ')';
+  };
+  protoOf(GpxTrack).hashCode = function () {
+    var result = this.k1g_1 == null ? 0 : getStringHashCode(this.k1g_1);
+    result = imul(result, 31) + (this.l1g_1 == null ? 0 : getStringHashCode(this.l1g_1)) | 0;
+    result = imul(result, 31) + hashCode(this.m1g_1) | 0;
+    return result;
+  };
+  protoOf(GpxTrack).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof GpxTrack))
+      return false;
+    if (!(this.k1g_1 == other.k1g_1))
+      return false;
+    if (!(this.l1g_1 == other.l1g_1))
+      return false;
+    if (!equals(this.m1g_1, other.m1g_1))
+      return false;
+    return true;
+  };
+  function GpxTrackPoint(latitudeDeg, longitudeDeg, elevationM, timeEpochMs, heartRate, cadence, temperatureC, powerW) {
+    elevationM = elevationM === VOID ? null : elevationM;
+    timeEpochMs = timeEpochMs === VOID ? null : timeEpochMs;
+    heartRate = heartRate === VOID ? null : heartRate;
+    cadence = cadence === VOID ? null : cadence;
+    temperatureC = temperatureC === VOID ? null : temperatureC;
+    powerW = powerW === VOID ? null : powerW;
+    this.n1g_1 = latitudeDeg;
+    this.o1g_1 = longitudeDeg;
+    this.p1g_1 = elevationM;
+    this.q1g_1 = timeEpochMs;
+    this.r1g_1 = heartRate;
+    this.s1g_1 = cadence;
+    this.t1g_1 = temperatureC;
+    this.u1g_1 = powerW;
+  }
+  protoOf(GpxTrackPoint).toString = function () {
+    return 'GpxTrackPoint(latitudeDeg=' + this.n1g_1 + ', longitudeDeg=' + this.o1g_1 + ', elevationM=' + this.p1g_1 + ', timeEpochMs=' + toString_0(this.q1g_1) + ', heartRate=' + this.r1g_1 + ', cadence=' + this.s1g_1 + ', temperatureC=' + this.t1g_1 + ', powerW=' + this.u1g_1 + ')';
+  };
+  protoOf(GpxTrackPoint).hashCode = function () {
+    var result = getNumberHashCode(this.n1g_1);
+    result = imul(result, 31) + getNumberHashCode(this.o1g_1) | 0;
+    result = imul(result, 31) + (this.p1g_1 == null ? 0 : getNumberHashCode(this.p1g_1)) | 0;
+    result = imul(result, 31) + (this.q1g_1 == null ? 0 : this.q1g_1.hashCode()) | 0;
+    result = imul(result, 31) + (this.r1g_1 == null ? 0 : this.r1g_1) | 0;
+    result = imul(result, 31) + (this.s1g_1 == null ? 0 : this.s1g_1) | 0;
+    result = imul(result, 31) + (this.t1g_1 == null ? 0 : getNumberHashCode(this.t1g_1)) | 0;
+    result = imul(result, 31) + (this.u1g_1 == null ? 0 : getNumberHashCode(this.u1g_1)) | 0;
+    return result;
+  };
+  protoOf(GpxTrackPoint).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof GpxTrackPoint))
+      return false;
+    if (!equals(this.n1g_1, other.n1g_1))
+      return false;
+    if (!equals(this.o1g_1, other.o1g_1))
+      return false;
+    if (!equals(this.p1g_1, other.p1g_1))
+      return false;
+    if (!equals(this.q1g_1, other.q1g_1))
+      return false;
+    if (!(this.r1g_1 == other.r1g_1))
+      return false;
+    if (!(this.s1g_1 == other.s1g_1))
+      return false;
+    if (!equals(this.t1g_1, other.t1g_1))
+      return false;
+    if (!equals(this.u1g_1, other.u1g_1))
+      return false;
+    return true;
+  };
+  function toGpxTrack(_this__u8e3s4, name, type) {
+    name = name === VOID ? null : name;
+    type = type === VOID ? 'cycling' : type;
+    // Inline function 'kotlin.collections.List' call
+    // Inline function 'kotlin.collections.MutableList' call
+    var size = _this__u8e3s4.v1g_1;
+    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 tmp = _this__u8e3s4.x1g(index) * MathConstants_getInstance().bv_1;
+        var tmp_0 = _this__u8e3s4.y1g(index) * MathConstants_getInstance().bv_1;
+        // Inline function 'kotlin.takeUnless' call
+        var this_0 = _this__u8e3s4.z1g(index);
+        var tmp_1;
+        if (!isNaN_0(this_0)) {
+          tmp_1 = this_0;
+        } else {
+          tmp_1 = null;
+        }
+        var tmp_2 = tmp_1;
+        // Inline function 'kotlin.takeIf' call
+        var this_1 = numberToLong(_this__u8e3s4.a1h(index));
+        var tmp_3;
+        if (compare(this_1, new Long(0, 0)) > 0) {
+          tmp_3 = this_1;
+        } else {
+          tmp_3 = null;
+        }
+        var tmp_4 = tmp_3;
+        // Inline function 'kotlin.takeUnless' call
+        var this_2 = _this__u8e3s4.b1h(index);
+        var tmp_5;
+        if (!(isNaN_0(this_2) || this_2 === 0.0)) {
+          tmp_5 = this_2;
+        } else {
+          tmp_5 = null;
+        }
+        var tmp0_safe_receiver = tmp_5;
+        var tmp_6 = tmp0_safe_receiver == null ? null : roundToInt(tmp0_safe_receiver);
+        // Inline function 'kotlin.takeUnless' call
+        var this_3 = _this__u8e3s4.c1h(index);
+        var tmp_7;
+        if (!(isNaN_0(this_3) || this_3 === 0.0)) {
+          tmp_7 = this_3;
+        } else {
+          tmp_7 = null;
+        }
+        var tmp1_safe_receiver = tmp_7;
+        var tmp_8 = tmp1_safe_receiver == null ? null : roundToInt(tmp1_safe_receiver);
+        // Inline function 'kotlin.takeUnless' call
+        var this_4 = _this__u8e3s4.d1h(index);
+        var tmp_9;
+        if (!(isNaN_0(this_4) || this_4 === 0.0)) {
+          tmp_9 = this_4;
+        } else {
+          tmp_9 = null;
+        }
+        var tmp_10 = tmp_9;
+        // Inline function 'kotlin.takeUnless' call
+        var this_5 = _this__u8e3s4.e1h(index);
+        var tmp_11;
+        if (!(isNaN_0(this_5) || this_5 === 0.0)) {
+          tmp_11 = this_5;
+        } else {
+          tmp_11 = null;
+        }
+        var tmp$ret$15 = tmp_11;
+        var tmp$ret$4 = new GpxTrackPoint(tmp, tmp_0, tmp_2, tmp_4, tmp_6, tmp_8, tmp_10, tmp$ret$15);
+        list.h(tmp$ret$4);
+      }
+       while (inductionVariable < size);
+    var points = list;
+    return new GpxTrack(name, type, points);
+  }
+  function toGpxDocument(_this__u8e3s4, name, trackName) {
+    name = name === VOID ? 'noname' : name;
+    trackName = trackName === VOID ? null : trackName;
+    return new GpxDocument(name, listOf(toGpxTrack(_this__u8e3s4, trackName)));
+  }
+  function parseDocument($this, reader) {
+    while (reader.j()) {
+      var ev = reader.k();
+      if (ev.equals(EventType_START_ELEMENT_getInstance())) {
+        if (!(reader.m14() === 'gpx')) {
+          throw IllegalArgumentException_init_$Create$('Invalid GPX file: missing gpx root element (found ' + reader.m14() + ')');
+        }
+        return parseGpxRoot($this, reader);
+      }
+    }
+    throw IllegalArgumentException_init_$Create$('Invalid GPX file: missing gpx root element');
+  }
+  function parseGpxRoot($this, reader) {
+    var name = 'noname';
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var tracks = ArrayList_init_$Create$_0();
+    while (reader.j()) {
+      var ev = reader.k();
+      switch (ev.l1_1) {
+        case 1:
+          switch (reader.m14()) {
+            case 'metadata':
+              var metaName = parseMetadataName($this, reader);
+              if (!(metaName == null))
+                name = metaName;
+              break;
+            case 'trk':
+              tracks.h(parseTrack($this, reader));
+              break;
+            default:
+              skipElement($this, reader);
+              break;
+          }
+
+          break;
+        case 2:
+          return new GpxDocument(name, tracks);
+        default:
+          break;
+      }
+    }
+    return new GpxDocument(name, tracks);
+  }
+  function parseMetadataName($this, reader) {
+    var name = null;
+    while (reader.j()) {
+      var ev = reader.k();
+      switch (ev.l1_1) {
+        case 1:
+          if (reader.m14() === 'name' && name == null) {
+            // Inline function 'kotlin.text.trim' call
+            var this_0 = readElementText($this, reader);
+            // Inline function 'kotlin.text.ifEmpty' call
+            var this_1 = toString(trim(isCharSequence(this_0) ? this_0 : THROW_CCE()));
+            var tmp;
+            // Inline function 'kotlin.text.isEmpty' call
+            if (charSequenceLength(this_1) === 0) {
+              tmp = null;
+            } else {
+              tmp = this_1;
+            }
+            name = tmp;
+          } else {
+            skipElement($this, reader);
+          }
+
+          break;
+        case 2:
+          return name;
+        default:
+          break;
+      }
+    }
+    return name;
+  }
+  function parseTrack($this, reader) {
+    var name = null;
+    var type = null;
+    // Inline function 'kotlin.collections.mutableListOf' call
+    var points = ArrayList_init_$Create$_0();
+    while (reader.j()) {
+      var ev = reader.k();
+      switch (ev.l1_1) {
+        case 1:
+          switch (reader.m14()) {
+            case 'name':
+              // Inline function 'kotlin.text.trim' call
+
+              var this_0 = readElementText($this, reader);
+              // Inline function 'kotlin.text.ifEmpty' call
+
+              var this_1 = toString(trim(isCharSequence(this_0) ? this_0 : THROW_CCE()));
+              var tmp;
+              // Inline function 'kotlin.text.isEmpty' call
+
+              if (charSequenceLength(this_1) === 0) {
+                tmp = null;
+              } else {
+                tmp = this_1;
+              }
+
+              name = tmp;
+              break;
+            case 'type':
+              // Inline function 'kotlin.text.trim' call
+
+              var this_2 = readElementText($this, reader);
+              // Inline function 'kotlin.text.ifEmpty' call
+
+              var this_3 = toString(trim(isCharSequence(this_2) ? this_2 : THROW_CCE()));
+              var tmp_0;
+              // Inline function 'kotlin.text.isEmpty' call
+
+              if (charSequenceLength(this_3) === 0) {
+                tmp_0 = null;
+              } else {
+                tmp_0 = this_3;
+              }
+
+              type = tmp_0;
+              break;
+            case 'trkseg':
+              parseTrackSegment($this, reader, points);
+              break;
+            default:
+              skipElement($this, reader);
+              break;
+          }
+
+          break;
+        case 2:
+          return new GpxTrack(name, type, points);
+        default:
+          break;
+      }
+    }
+    return new GpxTrack(name, type, points);
+  }
+  function parseTrackSegment($this, reader, accum) {
+    while (reader.j()) {
+      var ev = reader.k();
+      switch (ev.l1_1) {
+        case 1:
+          if (reader.m14() === 'trkpt') {
+            accum.h(parseTrackPoint($this, reader));
+          } else {
+            skipElement($this, reader);
+          }
+
+          break;
+        case 2:
+          return Unit_instance;
+        default:
+          break;
+      }
+    }
+  }
+  function parseTrackPoint($this, reader) {
+    var latStr = reader.x14(null, 'lat');
+    var lonStr = reader.x14(null, 'lon');
+    var tmp;
+    // Inline function 'kotlin.text.isNullOrBlank' call
+    if (latStr == null || isBlank(latStr)) {
+      tmp = true;
+    } else {
+      // Inline function 'kotlin.text.isNullOrBlank' call
+      tmp = lonStr == null || isBlank(lonStr);
+    }
+    if (tmp) {
+      throw IllegalArgumentException_init_$Create$('Invalid track point: missing latitude or longitude attribute');
+    }
+    var tmp0_elvis_lhs = toDoubleOrNull(latStr);
+    var tmp_0;
+    if (tmp0_elvis_lhs == null) {
+      throw IllegalArgumentException_init_$Create$("Invalid track point: latitude '" + latStr + "' is not a valid number");
+    } else {
+      tmp_0 = tmp0_elvis_lhs;
+    }
+    var lat = tmp_0;
+    var tmp1_elvis_lhs = toDoubleOrNull(lonStr);
+    var tmp_1;
+    if (tmp1_elvis_lhs == null) {
+      throw IllegalArgumentException_init_$Create$("Invalid track point: longitude '" + lonStr + "' is not a valid number");
+    } else {
+      tmp_1 = tmp1_elvis_lhs;
+    }
+    var lon = tmp_1;
+    var elevation = null;
+    var timeMs = null;
+    var ext = new ExtensionsAccumulator();
+    while (reader.j()) {
+      var ev = reader.k();
+      switch (ev.l1_1) {
+        case 1:
+          switch (reader.m14()) {
+            case 'ele':
+              // Inline function 'kotlin.text.trim' call
+
+              var this_0 = readElementText($this, reader);
+              var txt = toString(trim(isCharSequence(this_0) ? this_0 : THROW_CCE()));
+              // Inline function 'kotlin.text.isNotEmpty' call
+
+              if (charSequenceLength(txt) > 0) {
+                var tmp4_elvis_lhs = toDoubleOrNull(txt);
+                elevation = tmp4_elvis_lhs == null ? elevation : tmp4_elvis_lhs;
+              }
+
+              break;
+            case 'time':
+              // Inline function 'kotlin.text.trim' call
+
+              var this_1 = readElementText($this, reader);
+              var txt_0 = toString(trim(isCharSequence(this_1) ? this_1 : THROW_CCE()));
+              // Inline function 'kotlin.text.isNotEmpty' call
+
+              if (charSequenceLength(txt_0) > 0)
+                timeMs = parseTimeIsoToMs($this, txt_0);
+              break;
+            case 'extensions':
+              parseExtensions($this, reader, ext);
+              break;
+            default:
+              skipElement($this, reader);
+              break;
+          }
+
+          break;
+        case 2:
+          return new GpxTrackPoint(lat, lon, elevation, timeMs, ext.f1h_1, ext.g1h_1, ext.h1h_1, ext.i1h_1);
+        default:
+          break;
+      }
+    }
+    return new GpxTrackPoint(lat, lon, elevation, timeMs, ext.f1h_1, ext.g1h_1, ext.h1h_1, ext.i1h_1);
+  }
+  function parseExtensions($this, reader, ext) {
+    while (reader.j()) {
+      var ev = reader.k();
+      switch (ev.l1_1) {
+        case 1:
+          var ln = reader.m14();
+          // Inline function 'kotlin.text.lowercase' call
+
+          // Inline function 'kotlin.js.asDynamic' call
+
+          switch (ln.toLowerCase()) {
+            case 'power':
+              var tmp2_safe_receiver = readNumeric($this, reader);
+              if (tmp2_safe_receiver == null)
+                null;
+              else {
+                // Inline function 'kotlin.let' call
+                var tmp = ext;
+                var tmp0_elvis_lhs = ext.i1h_1;
+                tmp.i1h_1 = tmp0_elvis_lhs == null ? tmp2_safe_receiver : tmp0_elvis_lhs;
+              }
+
+              break;
+            case 'hr':
+            case 'heartrate':
+              var tmp3_safe_receiver = readNumeric($this, reader);
+              if (tmp3_safe_receiver == null)
+                null;
+              else {
+                // Inline function 'kotlin.let' call
+                if (ext.f1h_1 == null)
+                  ext.f1h_1 = numberToInt(tmp3_safe_receiver);
+              }
+
+              break;
+            case 'cad':
+            case 'cadence':
+              var tmp4_safe_receiver = readNumeric($this, reader);
+              if (tmp4_safe_receiver == null)
+                null;
+              else {
+                // Inline function 'kotlin.let' call
+                if (ext.g1h_1 == null)
+                  ext.g1h_1 = numberToInt(tmp4_safe_receiver);
+              }
+
+              break;
+            case 'atemp':
+            case 'temperature':
+            case 'temp':
+              var tmp5_safe_receiver = readNumeric($this, reader);
+              if (tmp5_safe_receiver == null)
+                null;
+              else {
+                // Inline function 'kotlin.let' call
+                var tmp_0 = ext;
+                var tmp0_elvis_lhs_0 = ext.h1h_1;
+                tmp_0.h1h_1 = tmp0_elvis_lhs_0 == null ? tmp5_safe_receiver : tmp0_elvis_lhs_0;
+              }
+
+              break;
+            default:
+              parseExtensions($this, reader, ext);
+              break;
+          }
+
+          break;
+        case 2:
+          return Unit_instance;
+        default:
+          break;
+      }
+    }
+  }
+  function readElementText($this, reader) {
+    var sb = StringBuilder_init_$Create$();
+    while (reader.j()) {
+      var ev = reader.k();
+      switch (ev.l1_1) {
+        case 4:
+        case 5:
+        case 9:
+          sb.j5(reader.q14());
+          break;
+        case 1:
+          skipElement($this, reader);
+          break;
+        case 2:
+          return sb.toString();
+        default:
+          break;
+      }
+    }
+    return sb.toString();
+  }
+  function readNumeric($this, reader) {
+    // Inline function 'kotlin.text.trim' call
+    var this_0 = readElementText($this, reader);
+    var txt = toString(trim(isCharSequence(this_0) ? this_0 : THROW_CCE()));
+    return toDoubleOrNull(txt);
+  }
+  function skipElement($this, reader) {
+    var depth = 1;
+    while (reader.j() && depth > 0) {
+      switch (reader.k().l1_1) {
+        case 1:
+          depth = depth + 1 | 0;
+          break;
+        case 2:
+          depth = depth - 1 | 0;
+          break;
+        default:
+          break;
+      }
+    }
+  }
+  function parseTimeIsoToMs($this, text) {
+    var tmp;
+    try {
+      tmp = Companion_getInstance().lb(text).pb();
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof IllegalArgumentException) {
+        var e = $p;
+        tmp_0 = null;
+      } else {
+        if ($p instanceof Error) {
+          var e_0 = $p;
+          tmp_0 = null;
+        } else {
+          throw $p;
+        }
+      }
+      tmp = tmp_0;
+    }
+    return tmp;
+  }
+  function ExtensionsAccumulator(heartRate, cadence, temperatureC, powerW) {
+    heartRate = heartRate === VOID ? null : heartRate;
+    cadence = cadence === VOID ? null : cadence;
+    temperatureC = temperatureC === VOID ? null : temperatureC;
+    powerW = powerW === VOID ? null : powerW;
+    this.f1h_1 = heartRate;
+    this.g1h_1 = cadence;
+    this.h1h_1 = temperatureC;
+    this.i1h_1 = powerW;
+  }
+  function GpxParser() {
+  }
+  protoOf(GpxParser).j1h = function (xml) {
+    var tmp;
+    try {
+      tmp = get_xmlStreaming().r15(xml);
+    } catch ($p) {
+      var tmp_0;
+      if ($p instanceof XmlException) {
+        var e = $p;
+        throw IllegalArgumentException_init_$Create$_0('Invalid GPX XML: ' + e.message, e);
+      } else {
+        throw $p;
+      }
+    }
+    var reader = tmp;
+    var tmp_1;
+    try {
+      tmp_1 = parseDocument(this, reader);
+    } catch ($p) {
+      var tmp_2;
+      if ($p instanceof XmlException) {
+        var e_0 = $p;
+        throw IllegalArgumentException_init_$Create$_0('Invalid GPX XML: ' + e_0.message, e_0);
+      } else {
+        throw $p;
+      }
+    }
+    finally {
+      reader.z14();
+    }
+    return tmp_1;
+  };
+  var GpxParser_instance;
+  function GpxParser_getInstance() {
+    return GpxParser_instance;
+  }
+  function firstTrackAsPath(_this__u8e3s4) {
+    var tmp0_elvis_lhs = firstOrNull(_this__u8e3s4.j1g_1);
+    var tmp;
+    if (tmp0_elvis_lhs == null) {
+      // Inline function 'kotlin.error' call
+      var message = 'GpxDocument has no track';
+      throw IllegalStateException_init_$Create$(toString(message));
+    } else {
+      tmp = tmp0_elvis_lhs;
+    }
+    var track = tmp;
+    return toPath(track);
+  }
+  function toPath(_this__u8e3s4) {
+    var n = _this__u8e3s4.m1g_1.l();
+    var path = new Path(n);
+    var iterator = _this__u8e3s4.m1g_1.i();
+    var index = 0;
+    while (iterator.j()) {
+      var i = index;
+      index = index + 1 | 0;
+      var p = iterator.k();
+      path.k1h(i, p.n1g_1 * MathConstants_getInstance().av_1);
+      path.l1h(i, p.o1g_1 * MathConstants_getInstance().av_1);
+      var tmp0_elvis_lhs = p.p1g_1;
+      path.m1h(i, tmp0_elvis_lhs == null ? 0.0 : tmp0_elvis_lhs);
+      var tmp1_elvis_lhs = p.q1g_1;
+      path.n1h(i, toNumber(tmp1_elvis_lhs == null ? new Long(0, 0) : tmp1_elvis_lhs));
+      var tmp2_safe_receiver = p.u1g_1;
+      if (tmp2_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        path.o1h(i, tmp2_safe_receiver);
+      }
+      var tmp3_safe_receiver = p.r1g_1;
+      if (tmp3_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        path.p1h(i, tmp3_safe_receiver);
+      }
+      var tmp4_safe_receiver = p.s1g_1;
+      if (tmp4_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        path.q1h(i, tmp4_safe_receiver);
+      }
+      var tmp5_safe_receiver = p.t1g_1;
+      if (tmp5_safe_receiver == null)
+        null;
+      else {
+        // Inline function 'kotlin.let' call
+        path.r1h(i, tmp5_safe_receiver);
+      }
+    }
+    path.b1i();
+    return path;
+  }
+  function writeDocument($this, w, document) {
+    w.a16('', 'http://www.topografix.com/GPX/1/1');
+    w.a16('xsi', 'http://www.w3.org/2001/XMLSchema-instance');
+    w.a16('gpxtpx', 'http://www.garmin.com/xmlschemas/TrackPointExtension/v1');
+    w.c16('http://www.topografix.com/GPX/1/1', 'gpx', '');
+    w.e16(null, 'version', null, '1.1');
+    w.e16(null, 'creator', null, '@glandais/vcyclist');
+    w.b16('', 'http://www.topografix.com/GPX/1/1');
+    w.b16('xsi', 'http://www.w3.org/2001/XMLSchema-instance');
+    w.b16('gpxtpx', 'http://www.garmin.com/xmlschemas/TrackPointExtension/v1');
+    w.e16('http://www.w3.org/2001/XMLSchema-instance', 'schemaLocation', 'xsi', 'http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd');
+    writeMetadata($this, w, document.i1g_1);
+    var _iterator__ex2g4s = document.j1g_1.i();
+    while (_iterator__ex2g4s.j()) {
+      var track = _iterator__ex2g4s.k();
+      writeTrack($this, w, track);
+    }
+    w.h16('http://www.topografix.com/GPX/1/1', 'gpx', '');
+  }
+  function writeMetadata($this, w, name) {
+    w.c16('http://www.topografix.com/GPX/1/1', 'metadata', '');
+    writeSimpleText($this, w, 'name', name);
+    w.h16('http://www.topografix.com/GPX/1/1', 'metadata', '');
+  }
+  function writeTrack($this, w, track) {
+    w.c16('http://www.topografix.com/GPX/1/1', 'trk', '');
+    var tmp0_safe_receiver = track.k1g_1;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      writeSimpleText(GpxWriter_instance, w, 'name', tmp0_safe_receiver);
+    }
+    var tmp1_safe_receiver = track.l1g_1;
+    if (tmp1_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      writeSimpleText(GpxWriter_instance, w, 'type', tmp1_safe_receiver);
+    }
+    w.c16('http://www.topografix.com/GPX/1/1', 'trkseg', '');
+    var _iterator__ex2g4s = track.m1g_1.i();
+    while (_iterator__ex2g4s.j()) {
+      var p = _iterator__ex2g4s.k();
+      writeTrackPoint($this, w, p);
+    }
+    w.h16('http://www.topografix.com/GPX/1/1', 'trkseg', '');
+    w.h16('http://www.topografix.com/GPX/1/1', 'trk', '');
+  }
+  function writeTrackPoint($this, w, p) {
+    w.c16('http://www.topografix.com/GPX/1/1', 'trkpt', '');
+    w.e16(null, 'lat', null, p.n1g_1.toString());
+    w.e16(null, 'lon', null, p.o1g_1.toString());
+    var tmp0_safe_receiver = p.q1g_1;
+    if (tmp0_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      writeSimpleText(GpxWriter_instance, w, 'time', Companion_getInstance().ib(tmp0_safe_receiver).toString());
+    }
+    var tmp1_safe_receiver = p.p1g_1;
+    if (tmp1_safe_receiver == null)
+      null;
+    else {
+      // Inline function 'kotlin.let' call
+      writeSimpleText(GpxWriter_instance, w, 'ele', tmp1_safe_receiver.toString());
+    }
+    var hasGarminExt = !(p.r1g_1 == null) || !(p.s1g_1 == null) || !(p.t1g_1 == null);
+    var hasPower = !(p.u1g_1 == null);
+    if (hasGarminExt || hasPower) {
+      w.c16('http://www.topografix.com/GPX/1/1', 'extensions', '');
+      if (hasPower) {
+        writeSimpleText($this, w, 'power', p.u1g_1.toString());
+      }
+      if (hasGarminExt) {
+        w.c16('http://www.garmin.com/xmlschemas/TrackPointExtension/v1', 'TrackPointExtension', 'gpxtpx');
+        var tmp2_safe_receiver = p.r1g_1;
+        if (tmp2_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          writeNamespaced(GpxWriter_instance, w, 'http://www.garmin.com/xmlschemas/TrackPointExtension/v1', 'hr', 'gpxtpx', tmp2_safe_receiver.toString());
+        }
+        var tmp3_safe_receiver = p.s1g_1;
+        if (tmp3_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          writeNamespaced(GpxWriter_instance, w, 'http://www.garmin.com/xmlschemas/TrackPointExtension/v1', 'cad', 'gpxtpx', tmp3_safe_receiver.toString());
+        }
+        var tmp4_safe_receiver = p.t1g_1;
+        if (tmp4_safe_receiver == null)
+          null;
+        else {
+          // Inline function 'kotlin.let' call
+          writeNamespaced(GpxWriter_instance, w, 'http://www.garmin.com/xmlschemas/TrackPointExtension/v1', 'atemp', 'gpxtpx', tmp4_safe_receiver.toString());
+        }
+        w.h16('http://www.garmin.com/xmlschemas/TrackPointExtension/v1', 'TrackPointExtension', 'gpxtpx');
+      }
+      w.h16('http://www.topografix.com/GPX/1/1', 'extensions', '');
+    }
+    w.h16('http://www.topografix.com/GPX/1/1', 'trkpt', '');
+  }
+  function writeSimpleText($this, w, localName, text) {
+    w.c16('http://www.topografix.com/GPX/1/1', localName, '');
+    w.d16(text);
+    w.h16('http://www.topografix.com/GPX/1/1', localName, '');
+  }
+  function writeNamespaced($this, w, namespace, localName, prefix, text) {
+    w.c16(namespace, localName, prefix);
+    w.d16(text);
+    w.h16(namespace, localName, prefix);
+  }
+  function GpxWriter() {
+    this.c1i_1 = 'http://www.topografix.com/GPX/1/1';
+    this.d1i_1 = 'http://www.w3.org/2001/XMLSchema-instance';
+    this.e1i_1 = 'http://www.garmin.com/xmlschemas/TrackPointExtension/v1';
+    this.f1i_1 = 'xsi';
+    this.g1i_1 = 'gpxtpx';
+    this.h1i_1 = 'http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/1/1/gpx.xsd';
+    this.i1i_1 = '@glandais/vcyclist';
+  }
+  protoOf(GpxWriter).j1i = function (document) {
+    var out = StringBuilder_init_$Create$();
+    out.j5('<?xml version="1.0" encoding="UTF-8"?>\n');
+    var writer = newGenericWriter(get_xmlStreaming(), out, false, XmlDeclMode_None_getInstance());
+    try {
+      writeDocument(this, writer, document);
+    }finally {
+      writer.z14();
+    }
+    return out.toString();
+  };
+  var GpxWriter_instance;
+  function GpxWriter_getInstance() {
+    return GpxWriter_instance;
+  }
+  function copyAllSlots($this, source) {
+    var out = new Path(source.v1g_1);
+    var inductionVariable = 0;
+    var last = source.v1g_1;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var _iterator__ex2g4s = get_entries().i();
+        while (_iterator__ex2g4s.j()) {
+          var field = _iterator__ex2g4s.k();
+          out.l1i(i, field, source.k1i(i, field));
+        }
+      }
+       while (inductionVariable < last);
+    return out;
+  }
+  function $fixElevationCOROUTINE$(_this__u8e3s4, source, provider, resultContinuation) {
+    CoroutineImpl.call(this, resultContinuation);
+    this.u1i_1 = _this__u8e3s4;
+    this.v1i_1 = source;
+    this.w1i_1 = provider;
+  }
+  protoOf($fixElevationCOROUTINE$).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            if (this.v1i_1.v1g_1 === 0)
+              return new Path(0);
+            var size = this.v1i_1.v1g_1;
+            var list = ArrayList_init_$Create$(size);
+            var inductionVariable = 0;
+            if (inductionVariable < size)
+              do {
+                var index = inductionVariable;
+                inductionVariable = inductionVariable + 1 | 0;
+                list.h(new LatLon(this.v1i_1.x1g(index) * MathConstants_getInstance().bv_1, this.v1i_1.y1g(index) * MathConstants_getInstance().bv_1));
+              }
+               while (inductionVariable < size);
+            var coords = list;
+            this.u5_1 = 1;
+            suspendResult = this.w1i_1.xy(coords, VOID, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            var corrected = suspendResult;
+            var out = copyAllSlots(this.u1i_1, this.v1i_1);
+            var inductionVariable_0 = 0;
+            var last = out.v1g_1;
+            if (inductionVariable_0 < last)
+              do {
+                var i = inductionVariable_0;
+                inductionVariable_0 = inductionVariable_0 + 1 | 0;
+                out.m1h(i, corrected.m(i).fv());
+              }
+               while (inductionVariable_0 < last);
+            out.b1i();
+            return out;
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  function ElevationStep() {
+    this.s1f_1 = 150.0;
+  }
+  protoOf(ElevationStep).t1f = function (source, provider, $completion) {
+    var tmp = new $fixElevationCOROUTINE$(this, source, provider, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(ElevationStep).x1i = function (source, windowM) {
+    if (source.v1g_1 === 0)
+      return new Path(0);
+    // Inline function 'kotlin.collections.List' call
+    // Inline function 'kotlin.collections.MutableList' call
+    var size = source.v1g_1;
+    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 tmp$ret$4 = source.y1i(index);
+        list.h(tmp$ret$4);
+      }
+       while (inductionVariable < size);
+    var coords = list;
+    var smoothed = ElevationSmoother_instance.uu(coords, windowM);
+    var out = copyAllSlots(this, source);
+    var inductionVariable_0 = 0;
+    var last = out.v1g_1;
+    if (inductionVariable_0 < last)
+      do {
+        var i = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        out.m1h(i, smoothed.m(i).fv());
+      }
+       while (inductionVariable_0 < last);
+    out.b1i();
+    return out;
+  };
+  protoOf(ElevationStep).u1f = function (source, windowM, $super) {
+    windowM = windowM === VOID ? 150.0 : windowM;
+    return $super === VOID ? this.x1i(source, windowM) : $super.x1i.call(this, source, windowM);
+  };
+  var ElevationStep_instance;
+  function ElevationStep_getInstance() {
+    return ElevationStep_instance;
+  }
+  function GeneratedPath(size) {
+    this.v1g_1 = size;
+    // Inline function 'kotlin.require' call
+    if (!(this.v1g_1 >= 0)) {
+      var message = 'Negative size: ' + this.v1g_1;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    this.w1g_1 = new Float64Array(imul(this.v1g_1, 36));
+  }
+  protoOf(GeneratedPath).k1i = function (i, field) {
+    return this.w1g_1[imul(i, 36) + field.l1_1 | 0];
+  };
+  protoOf(GeneratedPath).l1i = function (i, field, v) {
+    this.w1g_1[imul(i, 36) + field.l1_1 | 0] = v;
+  };
+  protoOf(GeneratedPath).x1g = function (i) {
+    return this.w1g_1[imul(i, 36) + 0 | 0];
+  };
+  protoOf(GeneratedPath).k1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 0 | 0] = v;
+  };
+  protoOf(GeneratedPath).y1g = function (i) {
+    return this.w1g_1[imul(i, 36) + 1 | 0];
+  };
+  protoOf(GeneratedPath).l1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 1 | 0] = v;
+  };
+  protoOf(GeneratedPath).z1i = function (i) {
+    return this.w1g_1[imul(i, 36) + 2 | 0];
+  };
+  protoOf(GeneratedPath).a1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 2 | 0] = v;
+  };
+  protoOf(GeneratedPath).b1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 3 | 0] = v;
+  };
+  protoOf(GeneratedPath).a1h = function (i) {
+    return this.w1g_1[imul(i, 36) + 4 | 0];
+  };
+  protoOf(GeneratedPath).n1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 4 | 0] = v;
+  };
+  protoOf(GeneratedPath).c1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 5 | 0] = v;
+  };
+  protoOf(GeneratedPath).d1j = function (i) {
+    return this.w1g_1[imul(i, 36) + 6 | 0];
+  };
+  protoOf(GeneratedPath).e1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 6 | 0] = v;
+  };
+  protoOf(GeneratedPath).f1j = function (i) {
+    return this.w1g_1[imul(i, 36) + 7 | 0];
+  };
+  protoOf(GeneratedPath).g1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 7 | 0] = v;
+  };
+  protoOf(GeneratedPath).z1g = function (i) {
+    return this.w1g_1[imul(i, 36) + 8 | 0];
+  };
+  protoOf(GeneratedPath).m1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 8 | 0] = v;
+  };
+  protoOf(GeneratedPath).h1j = function (i) {
+    return this.w1g_1[imul(i, 36) + 9 | 0];
+  };
+  protoOf(GeneratedPath).i1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 9 | 0] = v;
+  };
+  protoOf(GeneratedPath).j1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 10 | 0] = v;
+  };
+  protoOf(GeneratedPath).k1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 11 | 0] = v;
+  };
+  protoOf(GeneratedPath).l1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 12 | 0] = v;
+  };
+  protoOf(GeneratedPath).m1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 13 | 0] = v;
+  };
+  protoOf(GeneratedPath).n1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 14 | 0] = v;
+  };
+  protoOf(GeneratedPath).o1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 15 | 0] = v;
+  };
+  protoOf(GeneratedPath).p1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 16 | 0] = v;
+  };
+  protoOf(GeneratedPath).q1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 17 | 0] = v;
+  };
+  protoOf(GeneratedPath).e1h = function (i) {
+    return this.w1g_1[imul(i, 36) + 18 | 0];
+  };
+  protoOf(GeneratedPath).o1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 18 | 0] = v;
+  };
+  protoOf(GeneratedPath).r1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 19 | 0] = v;
+  };
+  protoOf(GeneratedPath).s1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 20 | 0] = v;
+  };
+  protoOf(GeneratedPath).t1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 21 | 0] = v;
+  };
+  protoOf(GeneratedPath).u1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 22 | 0] = v;
+  };
+  protoOf(GeneratedPath).v1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 23 | 0] = v;
+  };
+  protoOf(GeneratedPath).w1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 24 | 0] = v;
+  };
+  protoOf(GeneratedPath).x1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 25 | 0] = v;
+  };
+  protoOf(GeneratedPath).y1j = function (i) {
+    return this.w1g_1[imul(i, 36) + 26 | 0];
+  };
+  protoOf(GeneratedPath).z1j = function (i, v) {
+    this.w1g_1[imul(i, 36) + 26 | 0] = v;
+  };
+  protoOf(GeneratedPath).a1k = function (i) {
+    return this.w1g_1[imul(i, 36) + 27 | 0];
+  };
+  protoOf(GeneratedPath).b1k = function (i, v) {
+    this.w1g_1[imul(i, 36) + 27 | 0] = v;
+  };
+  protoOf(GeneratedPath).c1k = function (i) {
+    return this.w1g_1[imul(i, 36) + 28 | 0];
+  };
+  protoOf(GeneratedPath).d1k = function (i, v) {
+    this.w1g_1[imul(i, 36) + 28 | 0] = v;
+  };
+  protoOf(GeneratedPath).e1k = function (i, v) {
+    this.w1g_1[imul(i, 36) + 29 | 0] = v;
+  };
+  protoOf(GeneratedPath).f1k = function (i, v) {
+    this.w1g_1[imul(i, 36) + 30 | 0] = v;
+  };
+  protoOf(GeneratedPath).d1h = function (i) {
+    return this.w1g_1[imul(i, 36) + 31 | 0];
+  };
+  protoOf(GeneratedPath).r1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 31 | 0] = v;
+  };
+  protoOf(GeneratedPath).g1k = function (i, v) {
+    this.w1g_1[imul(i, 36) + 32 | 0] = v;
+  };
+  protoOf(GeneratedPath).h1k = function (i, v) {
+    this.w1g_1[imul(i, 36) + 33 | 0] = v;
+  };
+  protoOf(GeneratedPath).b1h = function (i) {
+    return this.w1g_1[imul(i, 36) + 34 | 0];
+  };
+  protoOf(GeneratedPath).p1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 34 | 0] = v;
+  };
+  protoOf(GeneratedPath).c1h = function (i) {
+    return this.w1g_1[imul(i, 36) + 35 | 0];
+  };
+  protoOf(GeneratedPath).q1h = function (i, v) {
+    this.w1g_1[imul(i, 36) + 35 | 0] = v;
+  };
+  function Companion_3() {
+    Companion_instance_3 = this;
+    this.i1k_1 = new BoundsRad(0.0, 0.0, 0.0, 0.0);
+  }
+  var Companion_instance_3;
+  function Companion_getInstance_4() {
+    if (Companion_instance_3 == null)
+      new Companion_3();
+    return Companion_instance_3;
+  }
+  function BoundsRad(minLat, maxLat, minLon, maxLon) {
+    Companion_getInstance_4();
+    this.j1k_1 = minLat;
+    this.k1k_1 = maxLat;
+    this.l1k_1 = minLon;
+    this.m1k_1 = maxLon;
+  }
+  protoOf(BoundsRad).toString = function () {
+    return 'BoundsRad(minLat=' + this.j1k_1 + ', maxLat=' + this.k1k_1 + ', minLon=' + this.l1k_1 + ', maxLon=' + this.m1k_1 + ')';
+  };
+  protoOf(BoundsRad).hashCode = function () {
+    var result = getNumberHashCode(this.j1k_1);
+    result = imul(result, 31) + getNumberHashCode(this.k1k_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.l1k_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.m1k_1) | 0;
+    return result;
+  };
+  protoOf(BoundsRad).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof BoundsRad))
+      return false;
+    if (!equals(this.j1k_1, other.j1k_1))
+      return false;
+    if (!equals(this.k1k_1, other.k1k_1))
+      return false;
+    if (!equals(this.l1k_1, other.l1k_1))
+      return false;
+    if (!equals(this.m1k_1, other.m1k_1))
+      return false;
+    return true;
+  };
+  function copyStatsFrom($this, other) {
+    $this.u1h_1 = other.u1h_1;
+    $this.v1h_1 = other.v1h_1;
+    $this.w1h_1 = other.w1h_1;
+    $this.x1h_1 = other.x1h_1;
+    $this.y1h_1 = other.y1h_1;
+    $this.z1h_1 = other.z1h_1;
+    $this.a1i_1 = other.a1i_1;
+  }
+  function resetStats($this) {
+    $this.u1h_1 = 0.0;
+    $this.v1h_1 = 0.0;
+    $this.w1h_1 = 0.0;
+    $this.x1h_1 = 0.0;
+    $this.y1h_1 = 0.0;
+    $this.z1h_1 = 0.0;
+    $this.a1i_1 = Companion_getInstance_4().i1k_1;
+  }
+  function computeBearing($this, from, to) {
+    var lat1 = $this.x1g(from);
+    var lon1 = $this.y1g(from);
+    var lat2 = $this.x1g(to);
+    var lon2 = $this.y1g(to);
+    // Inline function 'kotlin.math.cos' call
+    var x1 = lon1 * Math.cos(lat1);
+    var y1 = lat1;
+    // Inline function 'kotlin.math.cos' call
+    var x2 = lon2 * Math.cos(lat2);
+    var y2 = lat2;
+    var dy = y2 - y1;
+    var dx = x2 - x1;
+    // Inline function 'kotlin.math.atan2' call
+    var y = -dy;
+    return Math.atan2(y, dx);
+  }
+  function Companion_4() {
+  }
+  var Companion_instance_4;
+  function Companion_getInstance_5() {
+    return Companion_instance_4;
+  }
+  function Path(size) {
+    GeneratedPath.call(this, size);
+    this.u1h_1 = 0.0;
+    this.v1h_1 = 0.0;
+    this.w1h_1 = 0.0;
+    this.x1h_1 = 0.0;
+    this.y1h_1 = 0.0;
+    this.z1h_1 = 0.0;
+    this.a1i_1 = Companion_getInstance_4().i1k_1;
+  }
+  protoOf(Path).n1k = function () {
+    return until(0, this.v1g_1);
+  };
+  protoOf(Path).o1k = function (i) {
+    return this.x1g(i) * MathConstants_getInstance().bv_1;
+  };
+  protoOf(Path).p1k = function (i) {
+    return this.y1g(i) * MathConstants_getInstance().bv_1;
+  };
+  protoOf(Path).y1i = function (i) {
+    return new LatLonElevation(this.o1k(i), this.p1k(i), this.z1g(i));
+  };
+  protoOf(Path).q1k = function () {
+    var out = new Path(this.v1g_1);
+    var tmp0 = this.w1g_1;
+    var tmp2 = out.w1g_1;
+    // Inline function 'kotlin.collections.copyInto' call
+    var endIndex = this.w1g_1.length;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    var tmp = tmp0;
+    // Inline function 'kotlin.js.unsafeCast' call
+    // Inline function 'kotlin.js.asDynamic' call
+    arrayCopy(tmp, tmp2, 0, 0, endIndex);
+    copyStatsFrom(out, this);
+    return out;
+  };
+  protoOf(Path).b1i = function () {
+    resetStats(this);
+    if (this.v1g_1 === 0)
+      return Unit_instance;
+    var timeStart = this.a1h(0);
+    var cumDist = 0.0;
+    var minLat = Infinity;
+    var maxLat = -Infinity;
+    var minLon = Infinity;
+    var maxLon = -Infinity;
+    var minEle = Infinity;
+    var maxEle = -Infinity;
+    var gain = 0.0;
+    var loss = 0.0;
+    var inductionVariable = 0;
+    var last = this.v1g_1;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var lat = this.x1g(i);
+        var lon = this.y1g(i);
+        var ele = this.z1g(i);
+        // Inline function 'kotlin.math.min' call
+        var a = minLat;
+        minLat = Math.min(a, lat);
+        // Inline function 'kotlin.math.max' call
+        var a_0 = maxLat;
+        maxLat = Math.max(a_0, lat);
+        // Inline function 'kotlin.math.min' call
+        var a_1 = minLon;
+        minLon = Math.min(a_1, lon);
+        // Inline function 'kotlin.math.max' call
+        var a_2 = maxLon;
+        maxLon = Math.max(a_2, lon);
+        // Inline function 'kotlin.math.min' call
+        var a_3 = minEle;
+        minEle = Math.min(a_3, ele);
+        // Inline function 'kotlin.math.max' call
+        var a_4 = maxEle;
+        maxEle = Math.max(a_4, ele);
+        if (i > 0) {
+          var prevCoord = new LatLon(this.o1k(i - 1 | 0), this.p1k(i - 1 | 0));
+          var curCoord = new LatLon(this.o1k(i), this.p1k(i));
+          cumDist = cumDist + Distance_instance.yu(prevCoord, curCoord);
+          var dEle = ele - this.z1g(i - 1 | 0);
+          if (dEle > 0)
+            gain = gain + dEle;
+          else
+            loss = loss + dEle;
+        }
+        this.a1j(i, cumDist);
+      }
+       while (inductionVariable < last);
+    this.u1h_1 = cumDist;
+    this.v1h_1 = minEle === Infinity ? 0.0 : minEle;
+    this.w1h_1 = maxEle === -Infinity ? 0.0 : maxEle;
+    this.x1h_1 = gain;
+    this.y1h_1 = loss;
+    this.a1i_1 = new BoundsRad(minLat, maxLat, minLon, maxLon);
+    this.z1h_1 = this.v1g_1 >= 2 ? this.a1h(this.v1g_1 - 1 | 0) - timeStart : 0.0;
+    var inductionVariable_0 = 0;
+    var last_0 = this.v1g_1;
+    if (inductionVariable_0 < last_0)
+      $l$loop: do {
+        var i_0 = inductionVariable_0;
+        inductionVariable_0 = inductionVariable_0 + 1 | 0;
+        this.c1j(i_0, (this.a1h(i_0) - timeStart) / 1000.0);
+        if (this.v1g_1 <= 1)
+          continue $l$loop;
+        // Inline function 'kotlin.math.max' call
+        var b = i_0 - 1 | 0;
+        var im1 = Math.max(0, b);
+        var tmp0 = this.v1g_1 - 1 | 0;
+        // Inline function 'kotlin.math.min' call
+        var b_0 = i_0 + 1 | 0;
+        var ip1 = Math.min(tmp0, b_0);
+        this.g1j(i_0, computeBearing(this, im1, ip1));
+        var dDist = (this.z1i(ip1) - this.z1i(im1)) / 2.0;
+        var dEle_0 = (this.z1g(ip1) - this.z1g(im1)) / 2.0;
+        var grade = dDist === 0.0 ? 0.0 : dEle_0 / dDist;
+        this.i1j(i_0, grade);
+        var dTime = (this.a1h(ip1) - this.a1h(im1)) / 2000.0;
+        this.b1j(i_0, dDist);
+        this.e1j(i_0, dTime);
+        this.b1k(i_0, dTime === 0.0 ? 0.0 : dDist / dTime);
+      }
+       while (inductionVariable_0 < last_0);
+  };
+  function PathSimplifier() {
+  }
+  protoOf(PathSimplifier).e1g = function (path, toleranceM, zExaggeration) {
+    if (path.v1g_1 <= 2)
+      return path.q1k();
+    var coords = ArrayList_init_$Create$(path.v1g_1);
+    var inductionVariable = 0;
+    var last = path.v1g_1;
+    if (inductionVariable < last)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        // Inline function 'kotlin.collections.plusAssign' call
+        var element = new LatLonElevation(path.x1g(i) * MathConstants_getInstance().bv_1, path.y1g(i) * MathConstants_getInstance().bv_1, path.z1g(i));
+        coords.h(element);
+      }
+       while (inductionVariable < last);
+    var simplified = DouglasPeucker_instance.vu(coords, toleranceM, zExaggeration);
+    var retainedIndices = ArrayList_init_$Create$(simplified.l());
+    var cursor = 0;
+    var _iterator__ex2g4s = simplified.i();
+    while (_iterator__ex2g4s.j()) {
+      var kept = _iterator__ex2g4s.k();
+      while (cursor < coords.l() && !(coords.m(cursor) === kept)) {
+        cursor = cursor + 1 | 0;
+      }
+      if (cursor === coords.l()) {
+        // Inline function 'kotlin.error' call
+        var message = 'PathSimplifier: retained point not found in source';
+        throw IllegalStateException_init_$Create$(toString(message));
+      }
+      // Inline function 'kotlin.collections.plusAssign' call
+      var element_0 = cursor;
+      retainedIndices.h(element_0);
+      cursor = cursor + 1 | 0;
+    }
+    var out = new Path(retainedIndices.l());
+    var iterator = retainedIndices.i();
+    var index = 0;
+    while (iterator.j()) {
+      var dstIdx = index;
+      index = index + 1 | 0;
+      var srcIdx = iterator.k();
+      var _iterator__ex2g4s_0 = get_entries().i();
+      while (_iterator__ex2g4s_0.j()) {
+        var field = _iterator__ex2g4s_0.k();
+        out.l1i(dstIdx, field, path.k1i(srcIdx, field));
+      }
+    }
+    out.b1i();
+    return out;
+  };
+  var PathSimplifier_instance;
+  function PathSimplifier_getInstance() {
+    return PathSimplifier_instance;
+  }
+  var PointField_LATITUDE_instance;
+  var PointField_LONGITUDE_instance;
+  var PointField_DISTANCE_instance;
+  var PointField_DX_instance;
+  var PointField_TIME_instance;
+  var PointField_ELAPSED_instance;
+  var PointField_DT_instance;
+  var PointField_BEARING_instance;
+  var PointField_ELEVATION_instance;
+  var PointField_GRADE_instance;
+  var PointField_RADIUS_instance;
+  var PointField_AERO_COEF_instance;
+  var PointField_WIND_BEARING_instance;
+  var PointField_WIND_ALPHA_instance;
+  var PointField_P_AERO_instance;
+  var PointField_P_GRAVITY_instance;
+  var PointField_P_ROLLING_RESISTANCE_instance;
+  var PointField_P_WHEEL_BEARINGS_instance;
+  var PointField_P_INPUT_POWER_instance;
+  var PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_instance;
+  var PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_HARMONICS_instance;
+  var PointField_P_CYCLIST_PROVIDED_POWER_NEEDED_instance;
+  var PointField_P_CYCLIST_PROVIDED_MUSCULAR_instance;
+  var PointField_P_CYCLIST_PROVIDED_WHEEL_instance;
+  var PointField_P_COMPUTED_TOTAL_POWER_instance;
+  var PointField_P_COMPUTED_WHEEL_POWER_instance;
+  var PointField_POWER_instance;
+  var PointField_SPEED_instance;
+  var PointField_SPEED_MAX_instance;
+  var PointField_SPEED_MAX_INCLINE_instance;
+  var PointField_VIRT_SPEED_CURRENT_instance;
+  var PointField_TEMPERATURE_instance;
+  var PointField_WIND_SPEED_instance;
+  var PointField_WIND_DIRECTION_instance;
+  var PointField_HEART_RATE_instance;
+  var PointField_CADENCE_instance;
+  function Companion_5() {
+    Companion_instance_5 = this;
+    this.r1k_1 = 36;
+    var tmp = this;
+    // Inline function 'kotlin.collections.associateBy' call
+    var this_0 = get_entries();
+    var capacity = coerceAtLeast(mapCapacity(collectionSizeOrDefault(this_0, 10)), 16);
+    // Inline function 'kotlin.collections.associateByTo' call
+    var destination = LinkedHashMap_init_$Create$(capacity);
+    var _iterator__ex2g4s = this_0.i();
+    while (_iterator__ex2g4s.j()) {
+      var element = _iterator__ex2g4s.k();
+      var tmp$ret$2 = element.v1k_1;
+      destination.p2(tmp$ret$2, element);
+    }
+    tmp.s1k_1 = destination;
+  }
+  var Companion_instance_5;
+  function Companion_getInstance_6() {
+    PointField_initEntries();
+    if (Companion_instance_5 == null)
+      new Companion_5();
+    return Companion_instance_5;
+  }
+  function values() {
+    return [PointField_LATITUDE_getInstance(), PointField_LONGITUDE_getInstance(), PointField_DISTANCE_getInstance(), PointField_DX_getInstance(), PointField_TIME_getInstance(), PointField_ELAPSED_getInstance(), PointField_DT_getInstance(), PointField_BEARING_getInstance(), PointField_ELEVATION_getInstance(), PointField_GRADE_getInstance(), PointField_RADIUS_getInstance(), PointField_AERO_COEF_getInstance(), PointField_WIND_BEARING_getInstance(), PointField_WIND_ALPHA_getInstance(), PointField_P_AERO_getInstance(), PointField_P_GRAVITY_getInstance(), PointField_P_ROLLING_RESISTANCE_getInstance(), PointField_P_WHEEL_BEARINGS_getInstance(), PointField_P_INPUT_POWER_getInstance(), PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_getInstance(), PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_HARMONICS_getInstance(), PointField_P_CYCLIST_PROVIDED_POWER_NEEDED_getInstance(), PointField_P_CYCLIST_PROVIDED_MUSCULAR_getInstance(), PointField_P_CYCLIST_PROVIDED_WHEEL_getInstance(), PointField_P_COMPUTED_TOTAL_POWER_getInstance(), PointField_P_COMPUTED_WHEEL_POWER_getInstance(), PointField_POWER_getInstance(), PointField_SPEED_getInstance(), PointField_SPEED_MAX_getInstance(), PointField_SPEED_MAX_INCLINE_getInstance(), PointField_VIRT_SPEED_CURRENT_getInstance(), PointField_TEMPERATURE_getInstance(), PointField_WIND_SPEED_getInstance(), PointField_WIND_DIRECTION_getInstance(), PointField_HEART_RATE_getInstance(), PointField_CADENCE_getInstance()];
+  }
+  function get_entries() {
+    if ($ENTRIES == null)
+      $ENTRIES = enumEntries(values());
+    return $ENTRIES;
+  }
+  var PointField_entriesInitialized;
+  function PointField_initEntries() {
+    if (PointField_entriesInitialized)
+      return Unit_instance;
+    PointField_entriesInitialized = true;
+    PointField_LATITUDE_instance = new PointField('LATITUDE', 0, 'latitude', 'radians', 'Latitude (radians)', PointFieldCategory_COORDINATES_getInstance(), true, true);
+    PointField_LONGITUDE_instance = new PointField('LONGITUDE', 1, 'longitude', 'radians', 'Longitude (radians)', PointFieldCategory_COORDINATES_getInstance(), true, true);
+    PointField_DISTANCE_instance = new PointField('DISTANCE', 2, 'distance', 'meters', 'Distance (meters)', PointFieldCategory_COORDINATES_getInstance());
+    PointField_DX_instance = new PointField('DX', 3, 'dx', 'meters', 'dx (meters)', PointFieldCategory_COORDINATES_getInstance());
+    PointField_TIME_instance = new PointField('TIME', 4, 'time', 'ms', 'Timestamp (ms since epoch)', PointFieldCategory_TEMPORAL_getInstance(), true);
+    PointField_ELAPSED_instance = new PointField('ELAPSED', 5, 'elapsed', 'ms', 'Elapsed duration (ms)', PointFieldCategory_TEMPORAL_getInstance());
+    PointField_DT_instance = new PointField('DT', 6, 'dt', 'ms', 'dt (ms)', PointFieldCategory_TEMPORAL_getInstance());
+    PointField_BEARING_instance = new PointField('BEARING', 7, 'bearing', 'radians', 'Direction bearing (radians)', PointFieldCategory_ANGLES_getInstance(), VOID, true);
+    PointField_ELEVATION_instance = new PointField('ELEVATION', 8, 'elevation', 'meters', 'Elevation (meters)', PointFieldCategory_ELEVATION_getInstance());
+    PointField_GRADE_instance = new PointField('GRADE', 9, 'grade', '%', 'Road grade/slope (%)', PointFieldCategory_GRADE_getInstance());
+    PointField_RADIUS_instance = new PointField('RADIUS', 10, 'radius', 'meters', 'Turn radius (meters)', PointFieldCategory_RADIUS_getInstance());
+    PointField_AERO_COEF_instance = new PointField('AERO_COEF', 11, 'aeroCoef', 'aero', 'Aerodynamic coefficient', PointFieldCategory_AERO_COEF_getInstance());
+    PointField_WIND_BEARING_instance = new PointField('WIND_BEARING', 12, 'windBearing', 'radians', 'Wind bearing (radians)', PointFieldCategory_CYCLIST_WIND_getInstance(), VOID, true);
+    PointField_WIND_ALPHA_instance = new PointField('WIND_ALPHA', 13, 'windAlpha', 'radians', 'Wind angle (radians)', PointFieldCategory_CYCLIST_WIND_getInstance(), VOID, true);
+    PointField_P_AERO_instance = new PointField('P_AERO', 14, 'pAero', 'watts', 'Aerodynamic power', PointFieldCategory_POWER_PHYSICS_getInstance());
+    PointField_P_GRAVITY_instance = new PointField('P_GRAVITY', 15, 'pGravity', 'watts', 'Gravitational power', PointFieldCategory_POWER_PHYSICS_getInstance());
+    PointField_P_ROLLING_RESISTANCE_instance = new PointField('P_ROLLING_RESISTANCE', 16, 'pRollingResistance', 'watts', 'Rolling resistance power', PointFieldCategory_POWER_PHYSICS_getInstance());
+    PointField_P_WHEEL_BEARINGS_instance = new PointField('P_WHEEL_BEARINGS', 17, 'pWheelBearings', 'watts', 'Wheel bearings power', PointFieldCategory_POWER_PHYSICS_getInstance());
+    PointField_P_INPUT_POWER_instance = new PointField('P_INPUT_POWER', 18, 'pInputPower', 'watts', 'GPX input power', PointFieldCategory_POWER_CYCLIST_getInstance());
+    PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_instance = new PointField('P_CYCLIST_PROVIDED_OPTIMAL_POWER', 19, 'pCyclistProvidedOptimalPower', 'watts', 'Optimal power', PointFieldCategory_POWER_CYCLIST_getInstance());
+    PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_HARMONICS_instance = new PointField('P_CYCLIST_PROVIDED_OPTIMAL_POWER_HARMONICS', 20, 'pCyclistProvidedOptimalPowerWithHarmonics', 'watts', 'Optimal power with harmonics', PointFieldCategory_POWER_CYCLIST_getInstance());
+    PointField_P_CYCLIST_PROVIDED_POWER_NEEDED_instance = new PointField('P_CYCLIST_PROVIDED_POWER_NEEDED', 21, 'pCyclistPowerNeeded', 'watts', 'Power needed', PointFieldCategory_POWER_CYCLIST_getInstance());
+    PointField_P_CYCLIST_PROVIDED_MUSCULAR_instance = new PointField('P_CYCLIST_PROVIDED_MUSCULAR', 22, 'pCyclistProvidedMuscular', 'watts', 'Raw cyclist power', PointFieldCategory_POWER_CYCLIST_getInstance());
+    PointField_P_CYCLIST_PROVIDED_WHEEL_instance = new PointField('P_CYCLIST_PROVIDED_WHEEL', 23, 'pCyclistProvidedWheel', 'watts', 'Cyclist power transmitted to ground', PointFieldCategory_POWER_CYCLIST_getInstance());
+    PointField_P_COMPUTED_TOTAL_POWER_instance = new PointField('P_COMPUTED_TOTAL_POWER', 24, 'pComputedTotalPower', 'watts', 'Power from kinetic energy change', PointFieldCategory_POWER_POST_getInstance());
+    PointField_P_COMPUTED_WHEEL_POWER_instance = new PointField('P_COMPUTED_WHEEL_POWER', 25, 'pComputedWheelPower', 'watts', 'Wheel power from kinetic energy change', PointFieldCategory_POWER_POST_getInstance());
+    PointField_POWER_instance = new PointField('POWER', 26, 'pComputedPower', 'watts', 'Total power (watts)', PointFieldCategory_POWER_POST_getInstance());
+    PointField_SPEED_instance = new PointField('SPEED', 27, 'speed', 'm/s', 'Current speed (m/s)', PointFieldCategory_SPEED_getInstance());
+    PointField_SPEED_MAX_instance = new PointField('SPEED_MAX', 28, 'speedMax', 'm/s', 'Maximum speed (m/s)', PointFieldCategory_SPEED_getInstance());
+    PointField_SPEED_MAX_INCLINE_instance = new PointField('SPEED_MAX_INCLINE', 29, 'speedMaxIncline', 'm/s', 'Max speed on incline (m/s)', PointFieldCategory_SPEED_getInstance());
+    PointField_VIRT_SPEED_CURRENT_instance = new PointField('VIRT_SPEED_CURRENT', 30, 'virtSpeedCurrent', 'm/s', 'Virtual current speed (m/s)', PointFieldCategory_SPEED_getInstance());
+    PointField_TEMPERATURE_instance = new PointField('TEMPERATURE', 31, 'temperature', 'celsius', 'Temperature (celsius)', PointFieldCategory_ENVIRONMENTAL_getInstance());
+    PointField_WIND_SPEED_instance = new PointField('WIND_SPEED', 32, 'windSpeed', 'm/s', 'Wind speed (m/s)', PointFieldCategory_ENVIRONMENTAL_getInstance());
+    PointField_WIND_DIRECTION_instance = new PointField('WIND_DIRECTION', 33, 'windDirection', 'radians', 'Wind direction (radians)', PointFieldCategory_ENVIRONMENTAL_getInstance(), VOID, true);
+    PointField_HEART_RATE_instance = new PointField('HEART_RATE', 34, 'heartRate', 'bpm', 'Heart rate (bpm)', PointFieldCategory_PHYSIOLOGICAL_getInstance());
+    PointField_CADENCE_instance = new PointField('CADENCE', 35, 'cadence', 'rpm', 'Pedaling cadence (rpm)', PointFieldCategory_PHYSIOLOGICAL_getInstance());
+    Companion_getInstance_6();
+  }
+  var $ENTRIES;
+  function PointField(name, ordinal, prop, unit, shortDescription, category, notSelectable, anglesInRadians) {
+    notSelectable = notSelectable === VOID ? false : notSelectable;
+    anglesInRadians = anglesInRadians === VOID ? false : anglesInRadians;
+    Enum.call(this, name, ordinal);
+    this.v1k_1 = prop;
+    this.w1k_1 = unit;
+    this.x1k_1 = shortDescription;
+    this.y1k_1 = category;
+    this.z1k_1 = notSelectable;
+    this.a1l_1 = anglesInRadians;
+  }
+  function PointField_LATITUDE_getInstance() {
+    PointField_initEntries();
+    return PointField_LATITUDE_instance;
+  }
+  function PointField_LONGITUDE_getInstance() {
+    PointField_initEntries();
+    return PointField_LONGITUDE_instance;
+  }
+  function PointField_DISTANCE_getInstance() {
+    PointField_initEntries();
+    return PointField_DISTANCE_instance;
+  }
+  function PointField_DX_getInstance() {
+    PointField_initEntries();
+    return PointField_DX_instance;
+  }
+  function PointField_TIME_getInstance() {
+    PointField_initEntries();
+    return PointField_TIME_instance;
+  }
+  function PointField_ELAPSED_getInstance() {
+    PointField_initEntries();
+    return PointField_ELAPSED_instance;
+  }
+  function PointField_DT_getInstance() {
+    PointField_initEntries();
+    return PointField_DT_instance;
+  }
+  function PointField_BEARING_getInstance() {
+    PointField_initEntries();
+    return PointField_BEARING_instance;
+  }
+  function PointField_ELEVATION_getInstance() {
+    PointField_initEntries();
+    return PointField_ELEVATION_instance;
+  }
+  function PointField_GRADE_getInstance() {
+    PointField_initEntries();
+    return PointField_GRADE_instance;
+  }
+  function PointField_RADIUS_getInstance() {
+    PointField_initEntries();
+    return PointField_RADIUS_instance;
+  }
+  function PointField_AERO_COEF_getInstance() {
+    PointField_initEntries();
+    return PointField_AERO_COEF_instance;
+  }
+  function PointField_WIND_BEARING_getInstance() {
+    PointField_initEntries();
+    return PointField_WIND_BEARING_instance;
+  }
+  function PointField_WIND_ALPHA_getInstance() {
+    PointField_initEntries();
+    return PointField_WIND_ALPHA_instance;
+  }
+  function PointField_P_AERO_getInstance() {
+    PointField_initEntries();
+    return PointField_P_AERO_instance;
+  }
+  function PointField_P_GRAVITY_getInstance() {
+    PointField_initEntries();
+    return PointField_P_GRAVITY_instance;
+  }
+  function PointField_P_ROLLING_RESISTANCE_getInstance() {
+    PointField_initEntries();
+    return PointField_P_ROLLING_RESISTANCE_instance;
+  }
+  function PointField_P_WHEEL_BEARINGS_getInstance() {
+    PointField_initEntries();
+    return PointField_P_WHEEL_BEARINGS_instance;
+  }
+  function PointField_P_INPUT_POWER_getInstance() {
+    PointField_initEntries();
+    return PointField_P_INPUT_POWER_instance;
+  }
+  function PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_getInstance() {
+    PointField_initEntries();
+    return PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_instance;
+  }
+  function PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_HARMONICS_getInstance() {
+    PointField_initEntries();
+    return PointField_P_CYCLIST_PROVIDED_OPTIMAL_POWER_HARMONICS_instance;
+  }
+  function PointField_P_CYCLIST_PROVIDED_POWER_NEEDED_getInstance() {
+    PointField_initEntries();
+    return PointField_P_CYCLIST_PROVIDED_POWER_NEEDED_instance;
+  }
+  function PointField_P_CYCLIST_PROVIDED_MUSCULAR_getInstance() {
+    PointField_initEntries();
+    return PointField_P_CYCLIST_PROVIDED_MUSCULAR_instance;
+  }
+  function PointField_P_CYCLIST_PROVIDED_WHEEL_getInstance() {
+    PointField_initEntries();
+    return PointField_P_CYCLIST_PROVIDED_WHEEL_instance;
+  }
+  function PointField_P_COMPUTED_TOTAL_POWER_getInstance() {
+    PointField_initEntries();
+    return PointField_P_COMPUTED_TOTAL_POWER_instance;
+  }
+  function PointField_P_COMPUTED_WHEEL_POWER_getInstance() {
+    PointField_initEntries();
+    return PointField_P_COMPUTED_WHEEL_POWER_instance;
+  }
+  function PointField_POWER_getInstance() {
+    PointField_initEntries();
+    return PointField_POWER_instance;
+  }
+  function PointField_SPEED_getInstance() {
+    PointField_initEntries();
+    return PointField_SPEED_instance;
+  }
+  function PointField_SPEED_MAX_getInstance() {
+    PointField_initEntries();
+    return PointField_SPEED_MAX_instance;
+  }
+  function PointField_SPEED_MAX_INCLINE_getInstance() {
+    PointField_initEntries();
+    return PointField_SPEED_MAX_INCLINE_instance;
+  }
+  function PointField_VIRT_SPEED_CURRENT_getInstance() {
+    PointField_initEntries();
+    return PointField_VIRT_SPEED_CURRENT_instance;
+  }
+  function PointField_TEMPERATURE_getInstance() {
+    PointField_initEntries();
+    return PointField_TEMPERATURE_instance;
+  }
+  function PointField_WIND_SPEED_getInstance() {
+    PointField_initEntries();
+    return PointField_WIND_SPEED_instance;
+  }
+  function PointField_WIND_DIRECTION_getInstance() {
+    PointField_initEntries();
+    return PointField_WIND_DIRECTION_instance;
+  }
+  function PointField_HEART_RATE_getInstance() {
+    PointField_initEntries();
+    return PointField_HEART_RATE_instance;
+  }
+  function PointField_CADENCE_getInstance() {
+    PointField_initEntries();
+    return PointField_CADENCE_instance;
+  }
+  var PointFieldCategory_COORDINATES_instance;
+  var PointFieldCategory_TEMPORAL_instance;
+  var PointFieldCategory_ANGLES_instance;
+  var PointFieldCategory_ELEVATION_instance;
+  var PointFieldCategory_GRADE_instance;
+  var PointFieldCategory_RADIUS_instance;
+  var PointFieldCategory_AERO_COEF_instance;
+  var PointFieldCategory_CYCLIST_WIND_instance;
+  var PointFieldCategory_POWER_PHYSICS_instance;
+  var PointFieldCategory_POWER_CYCLIST_instance;
+  var PointFieldCategory_POWER_POST_instance;
+  var PointFieldCategory_SPEED_instance;
+  var PointFieldCategory_ENVIRONMENTAL_instance;
+  var PointFieldCategory_PHYSIOLOGICAL_instance;
+  var PointFieldCategory_entriesInitialized;
+  function PointFieldCategory_initEntries() {
+    if (PointFieldCategory_entriesInitialized)
+      return Unit_instance;
+    PointFieldCategory_entriesInitialized = true;
+    PointFieldCategory_COORDINATES_instance = new PointFieldCategory('COORDINATES', 0, 'coordinates', 'Coordinates');
+    PointFieldCategory_TEMPORAL_instance = new PointFieldCategory('TEMPORAL', 1, 'temporal', 'Temporal');
+    PointFieldCategory_ANGLES_instance = new PointFieldCategory('ANGLES', 2, 'angles', 'Angles');
+    PointFieldCategory_ELEVATION_instance = new PointFieldCategory('ELEVATION', 3, 'elevation', '\uD83C\uDFD4\uFE0F Elevation');
+    PointFieldCategory_GRADE_instance = new PointFieldCategory('GRADE', 4, 'grade', '\uD83D\uDCD0 Grade');
+    PointFieldCategory_RADIUS_instance = new PointFieldCategory('RADIUS', 5, 'radius', 'Radius');
+    PointFieldCategory_AERO_COEF_instance = new PointFieldCategory('AERO_COEF', 6, 'aero_coef', 'Aero coef');
+    PointFieldCategory_CYCLIST_WIND_instance = new PointFieldCategory('CYCLIST_WIND', 7, 'cyclist_wind', 'Cyclist wind');
+    PointFieldCategory_POWER_PHYSICS_instance = new PointFieldCategory('POWER_PHYSICS', 8, 'power_physics', '\u26A1 Power Physics');
+    PointFieldCategory_POWER_CYCLIST_instance = new PointFieldCategory('POWER_CYCLIST', 9, 'power_cyclist', '\u26A1 Power Cyclist');
+    PointFieldCategory_POWER_POST_instance = new PointFieldCategory('POWER_POST', 10, 'power_post', '\u26A1 Power Post processed');
+    PointFieldCategory_SPEED_instance = new PointFieldCategory('SPEED', 11, 'speed', 'Speed & Motion');
+    PointFieldCategory_ENVIRONMENTAL_instance = new PointFieldCategory('ENVIRONMENTAL', 12, 'environmental', 'Environmental');
+    PointFieldCategory_PHYSIOLOGICAL_instance = new PointFieldCategory('PHYSIOLOGICAL', 13, 'physiological', 'Physiological');
+  }
+  function PointFieldCategory(name, ordinal, id, displayName) {
+    Enum.call(this, name, ordinal);
+    this.d1l_1 = id;
+    this.e1l_1 = displayName;
+  }
+  function PointFieldCategory_COORDINATES_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_COORDINATES_instance;
+  }
+  function PointFieldCategory_TEMPORAL_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_TEMPORAL_instance;
+  }
+  function PointFieldCategory_ANGLES_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_ANGLES_instance;
+  }
+  function PointFieldCategory_ELEVATION_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_ELEVATION_instance;
+  }
+  function PointFieldCategory_GRADE_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_GRADE_instance;
+  }
+  function PointFieldCategory_RADIUS_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_RADIUS_instance;
+  }
+  function PointFieldCategory_AERO_COEF_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_AERO_COEF_instance;
+  }
+  function PointFieldCategory_CYCLIST_WIND_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_CYCLIST_WIND_instance;
+  }
+  function PointFieldCategory_POWER_PHYSICS_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_POWER_PHYSICS_instance;
+  }
+  function PointFieldCategory_POWER_CYCLIST_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_POWER_CYCLIST_instance;
+  }
+  function PointFieldCategory_POWER_POST_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_POWER_POST_instance;
+  }
+  function PointFieldCategory_SPEED_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_SPEED_instance;
+  }
+  function PointFieldCategory_ENVIRONMENTAL_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_ENVIRONMENTAL_instance;
+  }
+  function PointFieldCategory_PHYSIOLOGICAL_getInstance() {
+    PointFieldCategory_initEntries();
+    return PointFieldCategory_PHYSIOLOGICAL_instance;
+  }
+  function Copy(sourceIndex) {
+    this.f1l_1 = sourceIndex;
+  }
+  protoOf(Copy).toString = function () {
+    return 'Copy(sourceIndex=' + this.f1l_1 + ')';
+  };
+  protoOf(Copy).hashCode = function () {
+    return this.f1l_1;
+  };
+  protoOf(Copy).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Copy))
+      return false;
+    if (!(this.f1l_1 === other.f1l_1))
+      return false;
+    return true;
+  };
+  function Interpolate(from, to, coef) {
+    this.g1l_1 = from;
+    this.h1l_1 = to;
+    this.i1l_1 = coef;
+  }
+  protoOf(Interpolate).toString = function () {
+    return 'Interpolate(from=' + this.g1l_1 + ', to=' + this.h1l_1 + ', coef=' + this.i1l_1 + ')';
+  };
+  protoOf(Interpolate).hashCode = function () {
+    var result = this.g1l_1;
+    result = imul(result, 31) + this.h1l_1 | 0;
+    result = imul(result, 31) + getNumberHashCode(this.i1l_1) | 0;
+    return result;
+  };
+  protoOf(Interpolate).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Interpolate))
+      return false;
+    if (!(this.g1l_1 === other.g1l_1))
+      return false;
+    if (!(this.h1l_1 === other.h1l_1))
+      return false;
+    if (!equals(this.i1l_1, other.i1l_1))
+      return false;
+    return true;
+  };
+  function buildPlan($this, source, minDistanceM, maxDistanceM) {
+    var n = source.v1g_1;
+    var plan = ArrayList_init_$Create$(n);
+    // Inline function 'kotlin.collections.plusAssign' call
+    var element = new Copy(0);
+    plan.h(element);
+    var lastAddedDistance = source.z1i(0);
+    var lastAddedIndex = 0;
+    var inductionVariable = 1;
+    if (inductionVariable < n)
+      $l$loop: do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var curDist = source.z1i(i);
+        var gap = curDist - lastAddedDistance;
+        if (gap < minDistanceM)
+          continue $l$loop;
+        else if (gap <= maxDistanceM) {
+          // Inline function 'kotlin.collections.plusAssign' call
+          var element_0 = new Copy(i);
+          plan.h(element_0);
+          lastAddedDistance = curDist;
+          lastAddedIndex = i;
+        } else {
+          // Inline function 'kotlin.math.ceil' call
+          var x = gap / maxDistanceM;
+          var tmp$ret$2 = Math.ceil(x);
+          var numSegments = numberToInt(tmp$ret$2);
+          var spacing = gap / numSegments;
+          var index1 = lastAddedIndex;
+          var inductionVariable_0 = 1;
+          if (inductionVariable_0 < numSegments)
+            do {
+              var j = inductionVariable_0;
+              inductionVariable_0 = inductionVariable_0 + 1 | 0;
+              var targetDistance = lastAddedDistance + j * spacing;
+              while (index1 < (i - 1 | 0) && source.z1i(index1 + 1 | 0) < targetDistance) {
+                index1 = index1 + 1 | 0;
+              }
+              var dist1 = source.z1i(index1);
+              var dist2 = source.z1i(index1 + 1 | 0);
+              var coef = (targetDistance - dist1) / (dist2 - dist1);
+              // Inline function 'kotlin.collections.plusAssign' call
+              var element_1 = new Interpolate(index1, index1 + 1 | 0, coef);
+              plan.h(element_1);
+            }
+             while (inductionVariable_0 < numSegments);
+          // Inline function 'kotlin.collections.plusAssign' call
+          var element_2 = new Copy(i);
+          plan.h(element_2);
+          lastAddedDistance = curDist;
+          lastAddedIndex = i;
+        }
+      }
+       while (inductionVariable < n);
+    return plan;
+  }
+  function materialize($this, source, plan) {
+    var out = new Path(plan.l());
+    var iterator = plan.i();
+    var index = 0;
+    while (iterator.j()) {
+      var dstIdx = index;
+      index = index + 1 | 0;
+      var op = iterator.k();
+      if (op instanceof Copy) {
+        copyFields($this, source, op.f1l_1, out, dstIdx);
+      } else {
+        if (op instanceof Interpolate) {
+          interpolateFields($this, source, op.g1l_1, op.h1l_1, op.i1l_1, out, dstIdx);
+        } else {
+          noWhenBranchMatchedException();
+        }
+      }
+    }
+    out.b1i();
+    return out;
+  }
+  function copyFields($this, src, srcIdx, dst, dstIdx) {
+    var _iterator__ex2g4s = get_entries().i();
+    while (_iterator__ex2g4s.j()) {
+      var field = _iterator__ex2g4s.k();
+      dst.l1i(dstIdx, field, src.k1i(srcIdx, field));
+    }
+  }
+  function interpolateFields($this, src, i1, i2, coef, dst, dstIdx) {
+    var _iterator__ex2g4s = get_entries().i();
+    while (_iterator__ex2g4s.j()) {
+      var field = _iterator__ex2g4s.k();
+      var v1 = src.k1i(i1, field);
+      var v2 = src.k1i(i2, field);
+      var v = isNaN_0(v1) || isNaN_0(v2) ? NaN : v1 + (v2 - v1) * coef;
+      dst.l1i(dstIdx, field, v);
+    }
+  }
+  function PointPerDistance() {
+  }
+  protoOf(PointPerDistance).r1f = function (source, minDistanceM, maxDistanceM) {
+    return this.j1l(source, minDistanceM, maxDistanceM);
+  };
+  protoOf(PointPerDistance).j1l = function (source, minDistanceM, maxDistanceM) {
+    // Inline function 'kotlin.require' call
+    if (!(maxDistanceM > 0.0)) {
+      var message = 'maxDistanceM must be > 0, got ' + maxDistanceM;
+      throw IllegalArgumentException_init_$Create$(toString(message));
+    }
+    if (source.v1g_1 === 0)
+      return new Path(0);
+    if (source.v1g_1 === 1) {
+      var out = new Path(1);
+      copyFields(this, source, 0, out, 0);
+      out.b1i();
+      return out;
+    }
+    var plan = buildPlan(this, source, minDistanceM, maxDistanceM);
+    return materialize(this, source, plan);
+  };
+  var PointPerDistance_instance;
+  function PointPerDistance_getInstance() {
+    return PointPerDistance_instance;
+  }
+  function Copy_0(sourceIndex) {
+    this.k1l_1 = sourceIndex;
+  }
+  protoOf(Copy_0).toString = function () {
+    return 'Copy(sourceIndex=' + this.k1l_1 + ')';
+  };
+  protoOf(Copy_0).hashCode = function () {
+    return this.k1l_1;
+  };
+  protoOf(Copy_0).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Copy_0))
+      return false;
+    if (!(this.k1l_1 === other.k1l_1))
+      return false;
+    return true;
+  };
+  function Interpolate_0(from, to, coef) {
+    this.l1l_1 = from;
+    this.m1l_1 = to;
+    this.n1l_1 = coef;
+  }
+  protoOf(Interpolate_0).toString = function () {
+    return 'Interpolate(from=' + this.l1l_1 + ', to=' + this.m1l_1 + ', coef=' + this.n1l_1 + ')';
+  };
+  protoOf(Interpolate_0).hashCode = function () {
+    var result = this.l1l_1;
+    result = imul(result, 31) + this.m1l_1 | 0;
+    result = imul(result, 31) + getNumberHashCode(this.n1l_1) | 0;
+    return result;
+  };
+  protoOf(Interpolate_0).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Interpolate_0))
+      return false;
+    if (!(this.l1l_1 === other.l1l_1))
+      return false;
+    if (!(this.m1l_1 === other.m1l_1))
+      return false;
+    if (!equals(this.n1l_1, other.n1l_1))
+      return false;
+    return true;
+  };
+  function buildPlan_0($this, source) {
+    var plan = LinkedHashMap_init_$Create$_0();
+    var n = source.v1g_1;
+    var inductionVariable = 0;
+    if (inductionVariable < n)
+      $l$loop_0: do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        var time1 = source.a1h(i);
+        // Inline function 'kotlin.math.floor' call
+        var x = time1 / 1000.0;
+        var tmp$ret$0 = Math.floor(x);
+        var epoch1 = numberToLong(tmp$ret$0);
+        var msInSec1 = subtract(numberToLong(time1), multiply(epoch1, new Long(1000, 0)));
+        if (i === 0 && !equalsLong(msInSec1, new Long(0, 0))) {
+          // Inline function 'kotlin.collections.set' call
+          var value = new Copy_0(i);
+          plan.p2(epoch1, value);
+        }
+        if (i === (n - 1 | 0)) {
+          if (!equalsLong(msInSec1, new Long(0, 0))) {
+            var tmp2 = add(epoch1, new Long(1, 0));
+            // Inline function 'kotlin.collections.set' call
+            var value_0 = new Copy_0(i);
+            plan.p2(tmp2, value_0);
+          }
+          continue $l$loop_0;
+        }
+        var time2 = source.a1h(i + 1 | 0);
+        // Inline function 'kotlin.math.floor' call
+        var x_0 = time2 / 1000.0;
+        var tmp$ret$3 = Math.floor(x_0);
+        var epoch2 = numberToLong(tmp$ret$3);
+        if (equalsLong(epoch1, epoch2))
+          continue $l$loop_0;
+        var duration12 = time2 - time1;
+        var epochStart = equalsLong(msInSec1, new Long(0, 0)) ? epoch1 : add(epoch1, new Long(1, 0));
+        var epochEnd = epoch2;
+        var e = epochStart;
+        while (compare(e, epochEnd) <= 0) {
+          // Inline function 'kotlin.Long.times' call
+          var this_0 = e;
+          var epochTime = toNumber(this_0) * 1000.0;
+          var coef = (epochTime - time1) / duration12;
+          var tmp2_0 = e;
+          // Inline function 'kotlin.collections.set' call
+          var value_1 = new Interpolate_0(i, i + 1 | 0, coef);
+          plan.p2(tmp2_0, value_1);
+          var _unary__edvuaz = e;
+          e = add(_unary__edvuaz, get_ONE());
+        }
+      }
+       while (inductionVariable < n);
+    return plan;
+  }
+  function materialize_0($this, source, plan) {
+    var sortedEpochs = sorted(plan.i1());
+    var out = new Path(sortedEpochs.l());
+    var iterator = sortedEpochs.i();
+    var index = 0;
+    $l$loop: while (iterator.j()) {
+      var idx = index;
+      index = index + 1 | 0;
+      var epoch = iterator.k();
+      var tmp0_elvis_lhs = plan.h1(epoch);
+      var tmp;
+      if (tmp0_elvis_lhs == null) {
+        continue $l$loop;
+      } else {
+        tmp = tmp0_elvis_lhs;
+      }
+      var data = tmp;
+      if (data instanceof Copy_0) {
+        copyFields_0($this, source, data.k1l_1, out, idx);
+      } else {
+        if (data instanceof Interpolate_0) {
+          interpolateFields_0($this, source, data.l1l_1, data.m1l_1, data.n1l_1, out, idx);
+        } else {
+          noWhenBranchMatchedException();
+        }
+      }
+      out.n1h(idx, toNumber(multiply(epoch, new Long(1000, 0))));
+    }
+    out.b1i();
+    return out;
+  }
+  function copyFields_0($this, src, srcIdx, dst, dstIdx) {
+    var _iterator__ex2g4s = get_entries().i();
+    while (_iterator__ex2g4s.j()) {
+      var field = _iterator__ex2g4s.k();
+      dst.l1i(dstIdx, field, src.k1i(srcIdx, field));
+    }
+  }
+  function interpolateFields_0($this, src, i1, i2, coef, dst, dstIdx) {
+    var _iterator__ex2g4s = get_entries().i();
+    while (_iterator__ex2g4s.j()) {
+      var field = _iterator__ex2g4s.k();
+      var v1 = src.k1i(i1, field);
+      var v2 = src.k1i(i2, field);
+      var v = isNaN_0(v1) || isNaN_0(v2) ? NaN : v1 + (v2 - v1) * coef;
+      dst.l1i(dstIdx, field, v);
+    }
+  }
+  function PointPerSecond() {
+  }
+  protoOf(PointPerSecond).d1g = function (source) {
+    if (source.v1g_1 === 0)
+      return new Path(0);
+    var plan = buildPlan_0(this, source);
+    return materialize_0(this, source, plan);
+  };
+  var PointPerSecond_instance;
+  function PointPerSecond_getInstance() {
+    return PointPerSecond_instance;
+  }
+  function computeWithWind($this, path, i, aeroCoef, wind) {
+    var speed = path.a1k(i);
+    var bearing = path.f1j(i);
+    path.g1k(i, wind.o1l_1);
+    path.h1k(i, wind.p1l_1);
+    var windDirectionAsBearing = 3.141592653589793 / 2.0 - wind.p1l_1;
+    path.l1j(i, windDirectionAsBearing);
+    var alpha = windDirectionAsBearing - bearing;
+    path.m1j(i, alpha);
+    var v = wind.o1l_1;
+    // Inline function 'kotlin.math.cos' call
+    var l1 = speed + v * Math.cos(alpha);
+    var l2 = l1 * l1;
+    var tmp = speed * speed + v * v;
+    var tmp_0 = 2.0 * speed * v;
+    // Inline function 'kotlin.math.cos' call
+    var l3 = tmp + tmp_0 * Math.cos(alpha);
+    var l4 = l2 / l3;
+    var lambda = l4 + 1.2 * (1.0 - l4);
+    var tmp_1 = -aeroCoef * lambda;
+    // Inline function 'kotlin.math.sqrt' call
+    return tmp_1 * Math.sqrt(l3) * l1 * speed;
+  }
+  function AeroPowerProvider() {
+    this.q1l_1 = 1.2;
+  }
+  protoOf(AeroPowerProvider).r1l = function (course, path, pointIndex) {
+    var aeroCoef = course.e1e_1.s1l(course, path, pointIndex);
+    path.k1j(pointIndex, aeroCoef);
+    var wind = course.f1e_1.t1l(course.c1e_1, path, pointIndex);
+    var tmp;
+    if (wind.o1l_1 === 0.0) {
+      var v = path.a1k(pointIndex);
+      tmp = -aeroCoef * v * v * v;
+    } else {
+      tmp = computeWithWind(this, path, pointIndex, aeroCoef, wind);
+    }
+    var pAir = tmp;
+    path.n1j(pointIndex, pAir);
+    return pAir;
+  };
+  var AeroPowerProvider_instance;
+  function AeroPowerProvider_getInstance() {
+    return AeroPowerProvider_instance;
+  }
+  function AeroProviderConstant() {
+  }
+  protoOf(AeroProviderConstant).s1l = function (course, path, pointIndex) {
+    var rho = course.d1e_1.u1l(course.c1e_1, path, pointIndex);
+    return course.i1e().o1e_1 * course.i1e().p1e_1 * rho / 2.0;
+  };
+  var AeroProviderConstant_instance;
+  function AeroProviderConstant_getInstance() {
+    return AeroProviderConstant_instance;
+  }
+  function Companion_6() {
+    this.v1l_1 = 0.05;
+    this.w1l_1 = 3.0;
+  }
+  var Companion_instance_6;
+  function Companion_getInstance_7() {
+    return Companion_instance_6;
+  }
+  function CyclistPowerProviderBase(useHarmonics, random) {
+    random = random === VOID ? Default_getInstance() : random;
+    this.x1l_1 = useHarmonics;
+    var tmp = this;
+    var tmp_0;
+    if (this.x1l_1) {
+      // Inline function 'kotlin.collections.List' call
+      // Inline function 'kotlin.collections.MutableList' call
+      var list = ArrayList_init_$Create$(20);
+      // Inline function 'kotlin.repeat' call
+      var inductionVariable = 0;
+      if (inductionVariable < 20)
+        do {
+          var index = inductionVariable;
+          inductionVariable = inductionVariable + 1 | 0;
+          var tmp$ret$4 = new Harmonic(1.0 + random.fa() * 9.0, random.fa() * 3.141592653589793, random.fa() * 0.01);
+          list.h(tmp$ret$4);
+        }
+         while (inductionVariable < 20);
+      tmp_0 = list;
+    } else {
+      tmp_0 = emptyList();
+    }
+    tmp.y1l_1 = tmp_0;
+  }
+  protoOf(CyclistPowerProviderBase).r1l = function (course, path, pointIndex) {
+    var power = this.z1l(course, path, pointIndex);
+    path.r1j(pointIndex, power);
+    if (this.x1l_1) {
+      var x = path.a1h(pointIndex) / 10000.0;
+      var _iterator__ex2g4s = this.y1l_1.i();
+      while (_iterator__ex2g4s.j()) {
+        var h = _iterator__ex2g4s.k();
+        var tmp = power;
+        var tmp_0 = h.c1m_1 * power;
+        // Inline function 'kotlin.math.cos' call
+        var x_0 = h.a1m_1 * x - h.b1m_1;
+        power = tmp + tmp_0 * Math.cos(x_0);
+      }
+    }
+    path.s1j(pointIndex, power);
+    var powerNeeded = -PowerComputer_instance.d1m(course, path, pointIndex, false);
+    path.t1j(pointIndex, powerNeeded);
+    return power;
+  };
+  function GravPowerProvider() {
+  }
+  protoOf(GravPowerProvider).r1l = function (course, path, pointIndex) {
+    var m = course.i1e().m1e_1;
+    var grade = path.h1j(pointIndex);
+    var speed = path.a1k(pointIndex);
+    var tmp = -m * 9.8 * speed;
+    // Inline function 'kotlin.math.atan' call
+    // Inline function 'kotlin.math.sin' call
+    var x = Math.atan(grade);
+    var p = tmp * Math.sin(x);
+    path.o1j(pointIndex, p);
+    return p;
+  };
+  var GravPowerProvider_instance;
+  function GravPowerProvider_getInstance() {
+    return GravPowerProvider_instance;
+  }
+  function Harmonic(freqRadS, phaseRad, amp) {
+    this.a1m_1 = freqRadS;
+    this.b1m_1 = phaseRad;
+    this.c1m_1 = amp;
+  }
+  protoOf(Harmonic).toString = function () {
+    return 'Harmonic(freqRadS=' + this.a1m_1 + ', phaseRad=' + this.b1m_1 + ', amp=' + this.c1m_1 + ')';
+  };
+  protoOf(Harmonic).hashCode = function () {
+    var result = getNumberHashCode(this.a1m_1);
+    result = imul(result, 31) + getNumberHashCode(this.b1m_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.c1m_1) | 0;
+    return result;
+  };
+  protoOf(Harmonic).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Harmonic))
+      return false;
+    if (!equals(this.a1m_1, other.a1m_1))
+      return false;
+    if (!equals(this.b1m_1, other.b1m_1))
+      return false;
+    if (!equals(this.c1m_1, other.c1m_1))
+      return false;
+    return true;
+  };
+  function computeCorneringLimit($this, course, currentIndex, window_0) {
+    var path = course.w1d_1;
+    var radius = computeRadiusWindowed($this, path, currentIndex, window_0);
+    // Inline function 'kotlin.math.sqrt' call
+    var x = 9.8 * radius * course.x1d_1.s1e();
+    var vMax = Math.sqrt(x);
+    // Inline function 'kotlin.math.min' call
+    var a = course.x1d_1.u1e();
+    var result = Math.min(a, vMax);
+    path.e1k(currentIndex, result);
+    return result;
+  }
+  function computeRadiusWindowed($this, path, i, k) {
+    // Inline function 'kotlin.math.max' call
+    var b = i - k | 0;
+    var mini = Math.max(0, b);
+    var tmp0 = path.v1g_1 - 1 | 0;
+    // Inline function 'kotlin.math.min' call
+    var b_0 = i + k | 0;
+    var maxi = Math.min(tmp0, b_0);
+    var totalBearingChange = $this.e1m(path.f1j(maxi) - path.f1j(mini));
+    var totalDistance = path.z1i(maxi) - path.z1i(mini);
+    // Inline function 'kotlin.math.abs' call
+    if (Math.abs(totalBearingChange) < 0.001) {
+      path.j1j(i, 200.0);
+      return 200.0;
+    }
+    // Inline function 'kotlin.math.abs' call
+    var raw = totalDistance / Math.abs(totalBearingChange);
+    // Inline function 'kotlin.math.min' call
+    // Inline function 'kotlin.math.max' call
+    var b_1 = Math.min(200.0, raw);
+    var clamped = Math.max(5.0, b_1);
+    path.j1j(i, clamped);
+    return clamped;
+  }
+  function computeBrakingLimit($this, course, currentIndex, nextIndex) {
+    var path = course.w1d_1;
+    var vf = path.c1k(nextIndex);
+    var a = course.x1d_1.t1e();
+    var d = path.z1i(nextIndex) - path.z1i(currentIndex);
+    // Inline function 'kotlin.math.sqrt' call
+    var x = vf * vf + 2.0 * a * d;
+    return Math.sqrt(x);
+  }
+  function MaxSpeedComputer() {
+    this.v1f_1 = 200.0;
+    this.w1f_1 = 5.0;
+    this.x1f_1 = 2.0;
+    this.y1f_1 = 0.001;
+    this.z1f_1 = 10;
+  }
+  protoOf(MaxSpeedComputer).a1g = function (course) {
+    var path = course.w1d_1;
+    var n = path.v1g_1;
+    var inductionVariable = n - 1 | 0;
+    if (0 <= inductionVariable)
+      do {
+        var i = inductionVariable;
+        inductionVariable = inductionVariable + -1 | 0;
+        if (i === (n - 1 | 0)) {
+          path.d1k(i, 2.0);
+        } else {
+          var cornering = computeCorneringLimit(this, course, i, 10);
+          var braking = computeBrakingLimit(this, course, i, i + 1 | 0);
+          // Inline function 'kotlin.math.min' call
+          var tmp$ret$0 = Math.min(cornering, braking);
+          path.d1k(i, tmp$ret$0);
+        }
+      }
+       while (0 <= inductionVariable);
+    path.b1i();
+  };
+  protoOf(MaxSpeedComputer).e1m = function (angleIn) {
+    var a = angleIn;
+    while (a > 3.141592653589793)
+      a = a - 2.0 * 3.141592653589793;
+    while (a < -3.141592653589793)
+      a = a + 2.0 * 3.141592653589793;
+    return a;
+  };
+  var MaxSpeedComputer_instance;
+  function MaxSpeedComputer_getInstance() {
+    return MaxSpeedComputer_instance;
+  }
+  function MuscularPowerProvider() {
+  }
+  protoOf(MuscularPowerProvider).r1l = function (course, path, pointIndex) {
+    var muscular = course.g1e_1.r1l(course, path, pointIndex);
+    path.u1j(pointIndex, muscular);
+    var wheel = muscular * course.j1e().u1d_1;
+    path.v1j(pointIndex, wheel);
+    return wheel;
+  };
+  var MuscularPowerProvider_instance;
+  function MuscularPowerProvider_getInstance() {
+    return MuscularPowerProvider_instance;
+  }
+  function getDtInner($this, pSum, equivalentMass, currentSpeed, dx, dt1Init, dt2Init) {
+    var dt1 = dt1Init;
+    var dt2 = dt2Init;
+    var tol = dx / 1.0E7;
+    while (dt2 - dt1 >= tol) {
+      var dtMid = (dt1 + dt2) / 2.0;
+      var dxMid = $this.f1m(pSum, equivalentMass, currentSpeed, dtMid);
+      if (dxMid < dx)
+        dt1 = dtMid;
+      else
+        dt2 = dtMid;
+    }
+    return (dt1 + dt2) / 2.0;
+  }
+  function PowerComputer() {
+  }
+  protoOf(PowerComputer).d1m = function (course, path, pointIndex, withCyclist) {
+    var pSum = 0.0;
+    pSum = pSum + WheelBearingsPowerProvider_instance.r1l(course, path, pointIndex);
+    pSum = pSum + RollingResistancePowerProvider_instance.r1l(course, path, pointIndex);
+    pSum = pSum + AeroPowerProvider_instance.r1l(course, path, pointIndex);
+    pSum = pSum + GravPowerProvider_instance.r1l(course, path, pointIndex);
+    if (withCyclist) {
+      pSum = pSum + MuscularPowerProvider_instance.r1l(course, path, pointIndex);
+    }
+    return pSum;
+  };
+  protoOf(PowerComputer).f1m = function (pSum, equivalentMass, currentSpeed, dt) {
+    // Inline function 'kotlin.math.sqrt' call
+    var x = dt * pSum / (0.5 * equivalentMass) + currentSpeed * currentSpeed;
+    var tmp0 = Math.sqrt(x);
+    // Inline function 'kotlin.math.max' call
+    var b = 0.5555555555555556;
+    var newSpeed = Math.max(tmp0, b);
+    return (currentSpeed + newSpeed) * dt / 2.0;
+  };
+  protoOf(PowerComputer).g1m = function (equivalentMass, s1, s2, dt) {
+    return 0.5 * equivalentMass * (s2 * s2 - s1 * s1) / dt;
+  };
+  protoOf(PowerComputer).h1m = function (pSum, equivalentMass, currentSpeed, dx) {
+    var dt = 0.1;
+    while (this.f1m(pSum, equivalentMass, currentSpeed, dt) <= dx) {
+      dt = dt + 0.1;
+    }
+    return getDtInner(this, pSum, equivalentMass, currentSpeed, dx, dt - 0.1, dt);
+  };
+  protoOf(PowerComputer).i1m = function (course, path, equivalentMass, i) {
+    if (i === 0) {
+      path.z1j(i, 0.0);
+      return Unit_instance;
+    }
+    var resistive = this.d1m(course, path, i - 1 | 0, false);
+    var s1 = path.a1k(i - 1 | 0);
+    var s2 = path.a1k(i);
+    var dtSeconds = path.d1j(i) / 1000.0;
+    var totPower = this.g1m(equivalentMass, s1, s2, dtSeconds);
+    path.w1j(i, totPower);
+    var powerWheel = totPower - resistive;
+    path.x1j(i, powerWheel);
+    // Inline function 'kotlin.math.max' call
+    var computed = Math.max(0.0, powerWheel) / course.j1e().u1d_1;
+    path.z1j(i, computed);
+  };
+  protoOf(PowerComputer).j1m = function (course) {
+    var m = course.x1d_1.m1e_1;
+    var totalInertia = course.y1d_1.r1d_1 + course.y1d_1.s1d_1;
+    return m + totalInertia / (course.y1d_1.t1d_1 * course.y1d_1.t1d_1);
+  };
+  protoOf(PowerComputer).k1m = function (course) {
+    return this.j1m(course.c1e_1);
+  };
+  var PowerComputer_instance;
+  function PowerComputer_getInstance() {
+    return PowerComputer_instance;
+  }
+  function PowerProviderConstant(power, useHarmonics, random) {
+    useHarmonics = useHarmonics === VOID ? false : useHarmonics;
+    random = random === VOID ? Default_getInstance() : random;
+    CyclistPowerProviderBase.call(this, useHarmonics, random);
+    this.n1m_1 = power;
+  }
+  protoOf(PowerProviderConstant).z1l = function (course, path, pointIndex) {
+    return this.n1m_1;
+  };
+  function RhoProviderDefault() {
+  }
+  protoOf(RhoProviderDefault).u1l = function (course, path, pointIndex) {
+    return 1.225;
+  };
+  var RhoProviderDefault_instance;
+  function RhoProviderDefault_getInstance() {
+    return RhoProviderDefault_instance;
+  }
+  function RhoProviderEstimate() {
+    this.o1m_1 = 101325.0;
+    this.p1m_1 = 288.15;
+    this.q1m_1 = 9.80665;
+    this.r1m_1 = 0.0065;
+    this.s1m_1 = 287.05;
+  }
+  protoOf(RhoProviderEstimate).u1l = function (course, path, pointIndex) {
+    var providedTemp = path.k1i(pointIndex, PointField_TEMPERATURE_getInstance());
+    var temperatureC = isNaN_0(providedTemp) || providedTemp === 0.0 ? 15.0 : providedTemp;
+    var providedElevation = path.z1g(pointIndex);
+    var altitude = isNaN_0(providedElevation) ? 0.0 : providedElevation;
+    var tKelvin = temperatureC + 273.15;
+    var tmp0 = 1.0 - 0.0065 * altitude / 288.15;
+    // Inline function 'kotlin.math.pow' call
+    var x = 9.80665 / (287.05 * 0.0065);
+    var pressure = 101325.0 * Math.pow(tmp0, x);
+    return pressure / (287.05 * tKelvin);
+  };
+  var RhoProviderEstimate_instance;
+  function RhoProviderEstimate_getInstance() {
+    return RhoProviderEstimate_instance;
+  }
+  function RollingResistancePowerProvider() {
+  }
+  protoOf(RollingResistancePowerProvider).r1l = function (course, path, pointIndex) {
+    var m = course.i1e().m1e_1;
+    var crr = course.j1e().q1d_1;
+    var grade = path.h1j(pointIndex);
+    var speed = path.a1k(pointIndex);
+    // Inline function 'kotlin.math.atan' call
+    // Inline function 'kotlin.math.cos' call
+    var x = Math.atan(grade);
+    var coef = Math.cos(x);
+    var p = -coef * m * 9.8 * speed * crr;
+    path.p1j(pointIndex, p);
+    return p;
+  };
+  var RollingResistancePowerProvider_instance;
+  function RollingResistancePowerProvider_getInstance() {
+    return RollingResistancePowerProvider_instance;
+  }
+  function copyAllFields($this, src, i, dst, j) {
+    var _iterator__ex2g4s = get_entries().i();
+    while (_iterator__ex2g4s.j()) {
+      var field = _iterator__ex2g4s.k();
+      dst.l1i(j, field, src.k1i(i, field));
+    }
+  }
+  function VirtualizeService() {
+    this.b1g_1 = 100000;
+  }
+  protoOf(VirtualizeService).c1g = function (course) {
+    var input = course.h1e();
+    var n = input.v1g_1;
+    if (n === 0)
+      return new Path(0);
+    if (n === 1) {
+      var singleton = new Path(1);
+      copyAllFields(this, input, 0, singleton, 0);
+      return singleton;
+    }
+    var mEq = PowerComputer_instance.k1m(course);
+    var out = new Path(n);
+    copyAllFields(this, input, 0, out, 0);
+    var speed = 0.5555555555555556;
+    var startTimeMs = 0.0;
+    var timeMs = startTimeMs;
+    out.n1h(0, timeMs);
+    out.c1j(0, 0.0);
+    out.b1k(0, speed);
+    out.f1k(0, speed);
+    var i = 1;
+    var iter = 0;
+    $l$loop: while (i < n) {
+      var dx = input.z1i(i) - input.z1i(i - 1 | 0);
+      var pSum = PowerComputer_instance.d1m(course, out, i - 1 | 0, true);
+      var dt = PowerComputer_instance.h1m(pSum, mEq, speed, dx);
+      var speedNew = 2.0 * dx / dt - speed;
+      copyAllFields(this, input, i, out, i);
+      var speedMax = input.c1k(i);
+      if (speedNew > speedMax) {
+        speedNew = speedMax;
+        dt = 2.0 * dx / (speedNew + speed);
+      }
+      speed = speedNew;
+      timeMs = timeMs + dt * 1000.0;
+      out.n1h(i, timeMs);
+      out.c1j(i, timeMs - startTimeMs);
+      out.b1j(i, dx);
+      out.e1j(i, dt * 1000.0);
+      out.b1k(i, speed);
+      out.f1k(i, speed);
+      i = i + 1 | 0;
+      var _unary__edvuaz = iter;
+      iter = _unary__edvuaz + 1 | 0;
+      if (_unary__edvuaz > 100000)
+        break $l$loop;
+    }
+    var progression = out.n1k();
+    var inductionVariable = progression.qa_1;
+    var last = progression.ra_1;
+    if (inductionVariable <= last)
+      do {
+        var j = inductionVariable;
+        inductionVariable = inductionVariable + 1 | 0;
+        PowerComputer_instance.i1m(course, out, mEq, j);
+      }
+       while (!(j === last));
+    out.b1i();
+    return out;
+  };
+  var VirtualizeService_instance;
+  function VirtualizeService_getInstance() {
+    return VirtualizeService_instance;
+  }
+  function WheelBearingsPowerProvider() {
+  }
+  protoOf(WheelBearingsPowerProvider).r1l = function (course, path, pointIndex) {
+    var speed = path.a1k(pointIndex);
+    var p = -speed * (91.0 + 8.7 * speed) / 1000.0;
+    path.q1j(pointIndex, p);
+    return p;
+  };
+  var WheelBearingsPowerProvider_instance;
+  function WheelBearingsPowerProvider_getInstance() {
+    return WheelBearingsPowerProvider_instance;
+  }
+  function Companion_7() {
+    Companion_instance_7 = this;
+    this.t1m_1 = new Wind(0.0, 0.0);
+  }
+  var Companion_instance_7;
+  function Companion_getInstance_8() {
+    if (Companion_instance_7 == null)
+      new Companion_7();
+    return Companion_instance_7;
+  }
+  function Wind(speedMS, directionRad) {
+    Companion_getInstance_8();
+    this.o1l_1 = speedMS;
+    this.p1l_1 = directionRad;
+  }
+  protoOf(Wind).toString = function () {
+    return 'Wind(speedMS=' + this.o1l_1 + ', directionRad=' + this.p1l_1 + ')';
+  };
+  protoOf(Wind).hashCode = function () {
+    var result = getNumberHashCode(this.o1l_1);
+    result = imul(result, 31) + getNumberHashCode(this.p1l_1) | 0;
+    return result;
+  };
+  protoOf(Wind).equals = function (other) {
+    if (this === other)
+      return true;
+    if (!(other instanceof Wind))
+      return false;
+    if (!equals(this.o1l_1, other.o1l_1))
+      return false;
+    if (!equals(this.p1l_1, other.p1l_1))
+      return false;
+    return true;
+  };
+  function WindProviderNone() {
+  }
+  protoOf(WindProviderNone).t1l = function (course, path, pointIndex) {
+    return Companion_getInstance_8().t1m_1;
+  };
+  var WindProviderNone_instance;
+  function WindProviderNone_getInstance() {
+    return WindProviderNone_instance;
+  }
+  function parseGpx(xml) {
+    return firstTrackAsPath(GpxParser_instance.j1h(xml));
+  }
+  function pathSize(path) {
+    return path.v1g_1;
+  }
+  function pathTotalDistance(path) {
+    return path.u1h_1;
+  }
+  function pathDurationMs(path) {
+    return path.z1h_1;
+  }
+  function pathElevationGain(path) {
+    return path.x1h_1;
+  }
+  function pathElevationLoss(path) {
+    return path.y1h_1;
+  }
+  function pointAt(path, i) {
+    return pointObj(path.o1k(i), path.p1k(i), path.z1g(i), path.a1h(i), path.a1k(i), path.y1j(i), path.z1i(i), path.h1j(i));
+  }
+  function writeGpx(path) {
+    return GpxWriter_instance.j1i(toGpxDocument(path, VOID, 'virtualized'));
+  }
+  function enhance(path, options) {
+    var tmp = GlobalScope_instance;
+    return promise(tmp, VOID, VOID, enhance$slambda_0(options, path, null));
+  }
+  function pointObj(latitudeDeg, longitudeDeg, elevation, timeMs, speed, pComputedPower, distance, grade) {
+    var o = {};
+    o.latitudeDeg = latitudeDeg;
+    o.longitudeDeg = longitudeDeg;
+    o.elevation = elevation;
+    o.timeMs = timeMs;
+    o.speed = speed;
+    o.pComputedPower = pComputedPower;
+    o.distance = distance;
+    o.grade = grade;
+    // Inline function 'kotlin.js.unsafeCast' call
+    return o;
+  }
+  function toEnhanceOptions(_this__u8e3s4) {
+    if (_this__u8e3s4 == null)
+      return defaultJsOptions();
+    var tmp0_elvis_lhs = _this__u8e3s4.fixElevation;
+    var tmp = tmp0_elvis_lhs == null ? false : tmp0_elvis_lhs;
+    var tmp1_elvis_lhs = _this__u8e3s4.computeMaxSpeeds;
+    var tmp_0 = tmp1_elvis_lhs == null ? true : tmp1_elvis_lhs;
+    var tmp2_elvis_lhs = _this__u8e3s4.virtualizeTrack;
+    var tmp_1 = tmp2_elvis_lhs == null ? true : tmp2_elvis_lhs;
+    var tmp3_elvis_lhs = _this__u8e3s4.computeOnePointPerSecond;
+    var tmp_2 = tmp3_elvis_lhs == null ? false : tmp3_elvis_lhs;
+    var tmp4_elvis_lhs = _this__u8e3s4.simplifyEnabled;
+    var tmp_3 = tmp4_elvis_lhs == null ? false : tmp4_elvis_lhs;
+    var tmp5_elvis_lhs = _this__u8e3s4.simplifyToleranceM;
+    var tmp_4 = tmp5_elvis_lhs == null ? 10.0 : tmp5_elvis_lhs;
+    var tmp6_elvis_lhs = _this__u8e3s4.simplifyZExaggeration;
+    return new EnhanceOptions(tmp, tmp_0, tmp_1, tmp_2, new SimplifyPathOptions(tmp_3, tmp_4, tmp6_elvis_lhs == null ? 3.0 : tmp6_elvis_lhs));
+  }
+  function defaultJsOptions() {
+    return new EnhanceOptions(false, true, true, false, new SimplifyPathOptions(false));
+  }
+  function enhance$slambda($options, $path, resultContinuation) {
+    this.c1n_1 = $options;
+    this.d1n_1 = $path;
+    CoroutineImpl.call(this, resultContinuation);
+  }
+  protoOf(enhance$slambda).f1n = function ($this$promise, $completion) {
+    var tmp = this.qz($this$promise, $completion);
+    tmp.w5_1 = Unit_instance;
+    tmp.x5_1 = null;
+    return tmp.c6();
+  };
+  protoOf(enhance$slambda).k6 = function (p1, $completion) {
+    return this.f1n((!(p1 == null) ? isInterface(p1, CoroutineScope) : false) ? p1 : THROW_CCE(), $completion);
+  };
+  protoOf(enhance$slambda).c6 = function () {
+    var suspendResult = this.w5_1;
+    $sm: do
+      try {
+        var tmp = this.u5_1;
+        switch (tmp) {
+          case 0:
+            this.v5_1 = 2;
+            var opts = toEnhanceOptions(this.c1n_1);
+            this.u5_1 = 1;
+            suspendResult = Enhancer_instance.g1g(this.d1n_1, null, opts, this);
+            if (suspendResult === get_COROUTINE_SUSPENDED()) {
+              return suspendResult;
+            }
+
+            continue $sm;
+          case 1:
+            return suspendResult;
+          case 2:
+            throw this.x5_1;
+        }
+      } catch ($p) {
+        var e = $p;
+        if (this.v5_1 === 2) {
+          throw e;
+        } else {
+          this.u5_1 = this.v5_1;
+          this.x5_1 = e;
+        }
+      }
+     while (true);
+  };
+  protoOf(enhance$slambda).qz = function ($this$promise, completion) {
+    var i = new enhance$slambda(this.c1n_1, this.d1n_1, completion);
+    i.e1n_1 = $this$promise;
+    return i;
+  };
+  function enhance$slambda_0($options, $path, resultContinuation) {
+    var i = new enhance$slambda($options, $path, resultContinuation);
+    var l = function ($this$promise, $completion) {
+      return i.f1n($this$promise, $completion);
+    };
+    l.$arity = 1;
+    return l;
+  }
+  //region block: init
+  Enhancer_instance = new Enhancer();
+  GpxParser_instance = new GpxParser();
+  GpxWriter_instance = new GpxWriter();
+  ElevationStep_instance = new ElevationStep();
+  Companion_instance_4 = new Companion_4();
+  PathSimplifier_instance = new PathSimplifier();
+  PointPerDistance_instance = new PointPerDistance();
+  PointPerSecond_instance = new PointPerSecond();
+  AeroPowerProvider_instance = new AeroPowerProvider();
+  AeroProviderConstant_instance = new AeroProviderConstant();
+  Companion_instance_6 = new Companion_6();
+  GravPowerProvider_instance = new GravPowerProvider();
+  MaxSpeedComputer_instance = new MaxSpeedComputer();
+  MuscularPowerProvider_instance = new MuscularPowerProvider();
+  PowerComputer_instance = new PowerComputer();
+  RhoProviderDefault_instance = new RhoProviderDefault();
+  RhoProviderEstimate_instance = new RhoProviderEstimate();
+  RollingResistancePowerProvider_instance = new RollingResistancePowerProvider();
+  VirtualizeService_instance = new VirtualizeService();
+  WheelBearingsPowerProvider_instance = new WheelBearingsPowerProvider();
+  WindProviderNone_instance = new WindProviderNone();
+  //endregion
+  //region block: exports
+  function $jsExportAll$(_) {
+    var io = _.io || (_.io = {});
+    var github = io.github || (io.github = {});
+    var glandais = github.glandais || (github.glandais = {});
+    var engine = glandais.engine || (glandais.engine = {});
+    engine.parseGpx = parseGpx;
+    engine.pathSize = pathSize;
+    engine.pathTotalDistance = pathTotalDistance;
+    engine.pathDurationMs = pathDurationMs;
+    engine.pathElevationGain = pathElevationGain;
+    engine.pathElevationLoss = pathElevationLoss;
+    engine.pointAt = pointAt;
+    engine.writeGpx = writeGpx;
+    engine.enhance = enhance;
+  }
+  $jsExportAll$(_);
+  kotlin_io_github_glandais_elevation.$jsExportAll$(_);
+  //endregion
+  return _;
+}));
+
+//# sourceMappingURL=vcyclist-engine.js.map