@glandais/vcyclist-engine 6.9.1 → 6.10.0

package/vcyclist-gpx.js

@@ -235,6 +235,7 @@
   initMetadataForClass(BoundsRad, 'BoundsRad');
   initMetadataForCompanion(Companion_8);
   initMetadataForClass(Path, 'Path', VOID, GeneratedPath);
+  initMetadataForClass(Simplified, 'Simplified');
   initMetadataForObject(PathSimplifier, 'PathSimplifier');
   initMetadataForCompanion(Companion_9);
   initMetadataForClass(PointField, 'PointField', VOID, Enum);
@@ -5060,12 +5061,36 @@
       return false;
     return true;
   };
+  function distancesOf($this, path) {
+    var tmp = 0;
+    var tmp_0 = path.q2b_1;
+    var tmp_1 = new Float64Array(tmp_0);
+    while (tmp < tmp_0) {
+      var tmp_2 = tmp;
+      tmp_1[tmp_2] = path.z2j(tmp_2);
+      tmp = tmp + 1 | 0;
+    }
+    return tmp_1;
+  }
+  function elevationsOf($this, path) {
+    var tmp = 0;
+    var tmp_0 = path.q2b_1;
+    var tmp_1 = new Float64Array(tmp_0);
+    while (tmp < tmp_0) {
+      var tmp_2 = tmp;
+      var source = path.a2k(tmp_2);
+      tmp_1[tmp_2] = isNaN_0(source) ? path.v2b(tmp_2) : source;
+      tmp = tmp + 1 | 0;
+    }
+    return tmp_1;
+  }
   function Banked(gainM, lossM, legCount) {
-    this.z2j_1 = gainM;
-    this.a2k_1 = lossM;
-    this.b2k_1 = legCount;
+    this.b2k_1 = gainM;
+    this.c2k_1 = lossM;
+    this.d2k_1 = legCount;
   }
-  function accumulate($this, h, threshold) {
+  function accumulate($this, h, threshold, risingLegs) {
+    risingLegs = risingLegs === VOID ? null : risingLegs;
     var gain = 0.0;
     var loss = 0.0;
     var legCount = 0;
@@ -5076,6 +5101,8 @@
     var dir = 0;
     var ref = h[0];
     var ext = h[0];
+    var iRef = 0;
+    var iExt = 0;
     var inductionVariable = 1;
     var last = h.length;
     if (inductionVariable < last)
@@ -5100,35 +5127,59 @@
               }
               dir = 1;
               ref = lo;
+              iRef = iLo;
               ext = e > hi ? e : hi;
+              iExt = iHi;
             } else {
               if (hi > h[0]) {
                 gain = gain + (hi - h[0]);
                 legCount = legCount + 1 | 0;
+                if (risingLegs == null)
+                  null;
+                else {
+                  // Inline function 'kotlin.intArrayOf' call
+                  var tmp$ret$0 = new Int32Array([0, iHi]);
+                  risingLegs.k(tmp$ret$0);
+                }
               }
               dir = -1;
               ref = hi;
+              iRef = iHi;
               ext = e < lo ? e : lo;
+              iExt = iLo;
             }
           }
         } else if (dir > 0) {
           if (e > ext) {
             ext = e;
+            iExt = i;
           } else if (ext - e >= threshold) {
             gain = gain + (ext - ref);
             legCount = legCount + 1 | 0;
+            if (risingLegs == null)
+              null;
+            else {
+              // Inline function 'kotlin.intArrayOf' call
+              var tmp$ret$1 = new Int32Array([iRef, iExt]);
+              risingLegs.k(tmp$ret$1);
+            }
             ref = ext;
+            iRef = iExt;
             ext = e;
+            iExt = i;
             dir = -1;
           }
         } else {
           if (e < ext) {
             ext = e;
+            iExt = i;
           } else if (e - ext >= threshold) {
             loss = loss + (ext - ref);
             legCount = legCount + 1 | 0;
             ref = ext;
+            iRef = iExt;
             ext = e;
+            iExt = i;
             dir = 1;
           }
         }
@@ -5137,6 +5188,13 @@
     if (dir > 0 && ext > ref) {
       gain = gain + (ext - ref);
       legCount = legCount + 1 | 0;
+      if (risingLegs == null)
+        null;
+      else {
+        // Inline function 'kotlin.intArrayOf' call
+        var tmp$ret$2 = new Int32Array([iRef, iExt]);
+        risingLegs.k(tmp$ret$2);
+      }
     } else if (dir < 0 && ext < ref) {
       loss = loss + (ext - ref);
       legCount = legCount + 1 | 0;
@@ -5145,32 +5203,13 @@
   }
   function ElevationGain() {
   }
-  protoOf(ElevationGain).c2k = function (path, options) {
+  protoOf(ElevationGain).e2k = function (path, options) {
     if (path.q2b_1 < 2)
       return Companion_instance_5.n2j(options);
-    var tmp = 0;
-    var tmp_0 = path.q2b_1;
-    var tmp_1 = new Float64Array(tmp_0);
-    while (tmp < tmp_0) {
-      var tmp_2 = tmp;
-      tmp_1[tmp_2] = path.d2k(tmp_2);
-      tmp = tmp + 1 | 0;
-    }
-    var distanceM = tmp_1;
-    var tmp_3 = 0;
-    var tmp_4 = path.q2b_1;
-    var tmp_5 = new Float64Array(tmp_4);
-    while (tmp_3 < tmp_4) {
-      var tmp_6 = tmp_3;
-      var source = path.e2k(tmp_6);
-      tmp_5[tmp_6] = isNaN_0(source) ? path.v2b(tmp_6) : source;
-      tmp_3 = tmp_3 + 1 | 0;
-    }
-    var elevationM = tmp_5;
-    return this.f2k(distanceM, elevationM, options);
+    return this.f2k(distancesOf(this, path), elevationsOf(this, path), options);
   };
   protoOf(ElevationGain).g2k = function (path, options) {
-    var result = this.c2k(path, options);
+    var result = this.e2k(path, options);
     path.f2d_1 = result.s2j_1;
     path.g2d_1 = result.t2j_1;
     return result;
@@ -5203,7 +5242,7 @@
       return new ElevationGainResult(rawGain, rawLoss, rawGain, rawLoss, 0.0, options.r2j_1, 0);
     }
     var banked = accumulate(this, profile, options.q2j_1);
-    return new ElevationGainResult(banked.z2j_1, banked.a2k_1, rawGain, rawLoss, options.q2j_1, options.r2j_1, banked.b2k_1);
+    return new ElevationGainResult(banked.b2k_1, banked.c2k_1, rawGain, rawLoss, options.q2j_1, options.r2j_1, banked.d2k_1);
   };
   var ElevationGain_instance;
   function ElevationGain_getInstance() {
@@ -5485,7 +5524,7 @@
       do {
         var i = inductionVariable_0;
         inductionVariable_0 = inductionVariable_0 + 1 | 0;
-        if (isNaN_0(out.e2k(i))) {
+        if (isNaN_0(out.a2k(i))) {
           out.e2l(i, source.v2b(i));
         }
         out.p2c(i, smoothed.p(i).s12());
@@ -5569,7 +5608,7 @@
   protoOf(GeneratedPath).o2c = function (i, v) {
     this.r2b_1[imul(i, 44) + 1 | 0] = v;
   };
-  protoOf(GeneratedPath).d2k = function (i) {
+  protoOf(GeneratedPath).z2j = function (i) {
     return this.r2b_1[imul(i, 44) + 2 | 0];
   };
   protoOf(GeneratedPath).j2l = function (i, v) {
@@ -5749,7 +5788,7 @@
   protoOf(GeneratedPath).b2n = function (i, v) {
     this.r2b_1[imul(i, 44) + 42 | 0] = v;
   };
-  protoOf(GeneratedPath).e2k = function (i) {
+  protoOf(GeneratedPath).a2k = function (i) {
     return this.r2b_1[imul(i, 44) + 43 | 0];
   };
   protoOf(GeneratedPath).e2l = function (i, v) {
@@ -5968,7 +6007,7 @@
         var b_0 = i_0 + 1 | 0;
         var ip1 = Math.min(tmp0, b_0);
         this.q2l(i_0, computeBearing(this, im1, ip1));
-        var dDist = (this.d2k(ip1) - this.d2k(im1)) / 2.0;
+        var dDist = (this.z2j(ip1) - this.z2j(im1)) / 2.0;
         var dEle_0 = (this.v2b(ip1) - this.v2b(im1)) / 2.0;
         var grade = dDist === 0.0 ? 0.0 : dEle_0 / dDist;
         this.s2l(i_0, grade);
@@ -5979,11 +6018,28 @@
       }
        while (inductionVariable_0 < last_0);
   };
+  function Simplified(path, indices) {
+    this.n2n_1 = path;
+    this.o2n_1 = indices;
+  }
   function PathSimplifier() {
   }
-  protoOf(PathSimplifier).n2n = function (path, toleranceM, zExaggeration) {
-    if (path.q2b_1 <= 2)
-      return path.m2n();
+  protoOf(PathSimplifier).p2n = function (path, toleranceM, zExaggeration) {
+    return this.q2n(path, toleranceM, zExaggeration).n2n_1;
+  };
+  protoOf(PathSimplifier).q2n = function (path, toleranceM, zExaggeration) {
+    if (path.q2b_1 <= 2) {
+      var tmp = path.m2n();
+      var tmp_0 = 0;
+      var tmp_1 = path.q2b_1;
+      var tmp_2 = new Int32Array(tmp_1);
+      while (tmp_0 < tmp_1) {
+        var tmp_3 = tmp_0;
+        tmp_2[tmp_3] = tmp_3;
+        tmp_0 = tmp_0 + 1 | 0;
+      }
+      return new Simplified(tmp, tmp_2);
+    }
     var coords = ArrayList_init_$Create$_0(path.q2b_1);
     var inductionVariable = 0;
     var last = path.q2b_1;
@@ -6032,7 +6088,7 @@
     out.f2d_1 = path.f2d_1;
     out.g2d_1 = path.g2d_1;
     out.h2d_1 = path.h2d_1;
-    return out;
+    return new Simplified(out, toIntArray(retainedIndices));
   };
   var PathSimplifier_instance;
   function PathSimplifier_getInstance() {
@@ -6138,7 +6194,7 @@
   var PointField_SOURCE_ELEVATION_instance;
   function Companion_9() {
     Companion_instance_10 = this;
-    this.o2n_1 = 44;
+    this.r2n_1 = 44;
     var tmp = this;
     // Inline function 'kotlin.collections.associateBy' call
     var this_0 = get_entries_3();
@@ -6151,10 +6207,10 @@
       var tmp$ret$2 = element.l2e_1;
       destination.v3(tmp$ret$2, element);
     }
-    tmp.p2n_1 = destination;
+    tmp.s2n_1 = destination;
   }
-  protoOf(Companion_9).q2n = function (prop) {
-    return this.p2n_1.t1(prop);
+  protoOf(Companion_9).t2n = function (prop) {
+    return this.s2n_1.t1(prop);
   };
   var Companion_instance_10;
   function Companion_getInstance_9() {
@@ -6399,8 +6455,8 @@
   var PointFieldCategory_ROAD_instance;
   function PointFieldCategory(name, ordinal, id, displayName) {
     Enum.call(this, name, ordinal);
-    this.t2n_1 = id;
-    this.u2n_1 = displayName;
+    this.w2n_1 = id;
+    this.x2n_1 = displayName;
   }
   function PointFieldCategory_COORDINATES_getInstance() {
     static_init_5();
@@ -6463,35 +6519,35 @@
     return PointFieldCategory_ROAD_instance;
   }
   function Copy(sourceIndex) {
-    this.v2n_1 = sourceIndex;
+    this.y2n_1 = sourceIndex;
   }
   protoOf(Copy).toString = function () {
-    return 'Copy(sourceIndex=' + this.v2n_1 + ')';
+    return 'Copy(sourceIndex=' + this.y2n_1 + ')';
   };
   protoOf(Copy).hashCode = function () {
-    return this.v2n_1;
+    return this.y2n_1;
   };
   protoOf(Copy).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Copy))
       return false;
-    if (!(this.v2n_1 === other.v2n_1))
+    if (!(this.y2n_1 === other.y2n_1))
       return false;
     return true;
   };
   function Interpolate(from, to, coef) {
-    this.w2n_1 = from;
-    this.x2n_1 = to;
-    this.y2n_1 = coef;
+    this.z2n_1 = from;
+    this.a2o_1 = to;
+    this.b2o_1 = coef;
   }
   protoOf(Interpolate).toString = function () {
-    return 'Interpolate(from=' + this.w2n_1 + ', to=' + this.x2n_1 + ', coef=' + this.y2n_1 + ')';
+    return 'Interpolate(from=' + this.z2n_1 + ', to=' + this.a2o_1 + ', coef=' + this.b2o_1 + ')';
   };
   protoOf(Interpolate).hashCode = function () {
-    var result = this.w2n_1;
-    result = imul(result, 31) + this.x2n_1 | 0;
-    result = imul(result, 31) + getNumberHashCode(this.y2n_1) | 0;
+    var result = this.z2n_1;
+    result = imul(result, 31) + this.a2o_1 | 0;
+    result = imul(result, 31) + getNumberHashCode(this.b2o_1) | 0;
     return result;
   };
   protoOf(Interpolate).equals = function (other) {
@@ -6499,11 +6555,11 @@
       return true;
     if (!(other instanceof Interpolate))
       return false;
-    if (!(this.w2n_1 === other.w2n_1))
+    if (!(this.z2n_1 === other.z2n_1))
       return false;
-    if (!(this.x2n_1 === other.x2n_1))
+    if (!(this.a2o_1 === other.a2o_1))
       return false;
-    if (!equals(this.y2n_1, other.y2n_1))
+    if (!equals(this.b2o_1, other.b2o_1))
       return false;
     return true;
   };
@@ -6513,14 +6569,14 @@
     // Inline function 'kotlin.collections.plusAssign' call
     var element = new Copy(0);
     plan.k(element);
-    var lastAddedDistance = source.d2k(0);
+    var lastAddedDistance = source.z2j(0);
     var lastAddedIndex = 0;
     var inductionVariable = 1;
     if (inductionVariable < n)
       $l$loop: do {
         var i = inductionVariable;
         inductionVariable = inductionVariable + 1 | 0;
-        var curDist = source.d2k(i);
+        var curDist = source.z2j(i);
         var gap = curDist - lastAddedDistance;
         if (gap < minDistanceM)
           continue $l$loop;
@@ -6543,11 +6599,11 @@
               var j = inductionVariable_0;
               inductionVariable_0 = inductionVariable_0 + 1 | 0;
               var targetDistance = lastAddedDistance + j * spacing;
-              while (index1 < (i - 1 | 0) && source.d2k(index1 + 1 | 0) < targetDistance) {
+              while (index1 < (i - 1 | 0) && source.z2j(index1 + 1 | 0) < targetDistance) {
                 index1 = index1 + 1 | 0;
               }
-              var dist1 = source.d2k(index1);
-              var dist2 = source.d2k(index1 + 1 | 0);
+              var dist1 = source.z2j(index1);
+              var dist2 = source.z2j(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);
@@ -6573,10 +6629,10 @@
       index = index + 1 | 0;
       var op = iterator.n();
       if (op instanceof Copy) {
-        copyFields($this, source, op.v2n_1, out, dstIdx);
+        copyFields($this, source, op.y2n_1, out, dstIdx);
       } else {
         if (op instanceof Interpolate) {
-          FieldInterpolation_getInstance().h2l(source, op.w2n_1, op.x2n_1, op.y2n_1, out, dstIdx);
+          FieldInterpolation_getInstance().h2l(source, op.z2n_1, op.a2o_1, op.b2o_1, out, dstIdx);
         } else {
           noWhenBranchMatchedException();
         }
@@ -6594,10 +6650,10 @@
   }
   function PointPerDistance() {
   }
-  protoOf(PointPerDistance).z2n = function (source, minDistanceM, maxDistanceM) {
-    return this.a2o(source, minDistanceM, maxDistanceM);
+  protoOf(PointPerDistance).c2o = function (source, minDistanceM, maxDistanceM) {
+    return this.d2o(source, minDistanceM, maxDistanceM);
   };
-  protoOf(PointPerDistance).a2o = function (source, minDistanceM, maxDistanceM) {
+  protoOf(PointPerDistance).d2o = function (source, minDistanceM, maxDistanceM) {
     // Inline function 'kotlin.require' call
     if (!(maxDistanceM > 0.0)) {
       var message = 'maxDistanceM must be > 0, got ' + maxDistanceM;
@@ -6619,35 +6675,35 @@
     return PointPerDistance_instance;
   }
   function Copy_0(sourceIndex) {
-    this.b2o_1 = sourceIndex;
+    this.e2o_1 = sourceIndex;
   }
   protoOf(Copy_0).toString = function () {
-    return 'Copy(sourceIndex=' + this.b2o_1 + ')';
+    return 'Copy(sourceIndex=' + this.e2o_1 + ')';
   };
   protoOf(Copy_0).hashCode = function () {
-    return this.b2o_1;
+    return this.e2o_1;
   };
   protoOf(Copy_0).equals = function (other) {
     if (this === other)
       return true;
     if (!(other instanceof Copy_0))
       return false;
-    if (!(this.b2o_1 === other.b2o_1))
+    if (!(this.e2o_1 === other.e2o_1))
       return false;
     return true;
   };
   function Interpolate_0(from, to, coef) {
-    this.c2o_1 = from;
-    this.d2o_1 = to;
-    this.e2o_1 = coef;
+    this.f2o_1 = from;
+    this.g2o_1 = to;
+    this.h2o_1 = coef;
   }
   protoOf(Interpolate_0).toString = function () {
-    return 'Interpolate(from=' + this.c2o_1 + ', to=' + this.d2o_1 + ', coef=' + this.e2o_1 + ')';
+    return 'Interpolate(from=' + this.f2o_1 + ', to=' + this.g2o_1 + ', coef=' + this.h2o_1 + ')';
   };
   protoOf(Interpolate_0).hashCode = function () {
-    var result = this.c2o_1;
-    result = imul(result, 31) + this.d2o_1 | 0;
-    result = imul(result, 31) + getNumberHashCode(this.e2o_1) | 0;
+    var result = this.f2o_1;
+    result = imul(result, 31) + this.g2o_1 | 0;
+    result = imul(result, 31) + getNumberHashCode(this.h2o_1) | 0;
     return result;
   };
   protoOf(Interpolate_0).equals = function (other) {
@@ -6655,11 +6711,11 @@
       return true;
     if (!(other instanceof Interpolate_0))
       return false;
-    if (!(this.c2o_1 === other.c2o_1))
+    if (!(this.f2o_1 === other.f2o_1))
       return false;
-    if (!(this.d2o_1 === other.d2o_1))
+    if (!(this.g2o_1 === other.g2o_1))
       return false;
-    if (!equals(this.e2o_1, other.e2o_1))
+    if (!equals(this.h2o_1, other.h2o_1))
       return false;
     return true;
   };
@@ -6737,10 +6793,10 @@
       }
       var data = tmp;
       if (data instanceof Copy_0) {
-        copyFields_0($this, source, data.b2o_1, out, idx);
+        copyFields_0($this, source, data.e2o_1, out, idx);
       } else {
         if (data instanceof Interpolate_0) {
-          FieldInterpolation_getInstance().h2l(source, data.c2o_1, data.d2o_1, data.e2o_1, out, idx);
+          FieldInterpolation_getInstance().h2l(source, data.f2o_1, data.g2o_1, data.h2o_1, out, idx);
         } else {
           noWhenBranchMatchedException();
         }
@@ -6759,7 +6815,7 @@
   }
   function PointPerSecond() {
   }
-  protoOf(PointPerSecond).f2o = function (source) {
+  protoOf(PointPerSecond).i2o = function (source) {
     if (source.q2b_1 === 0)
       return new Path(0);
     var plan = buildPlan_0(this, source);
@@ -6770,33 +6826,33 @@
     return PointPerSecond_instance;
   }
   function TunnelSpan(first, last, chordGrade, heightM, riseGrade, fallGrade, straightness, stepM) {
-    this.g2o_1 = first;
-    this.h2o_1 = last;
-    this.i2o_1 = chordGrade;
-    this.j2o_1 = heightM;
-    this.k2o_1 = riseGrade;
-    this.l2o_1 = fallGrade;
-    this.m2o_1 = straightness;
-    this.n2o_1 = stepM;
+    this.j2o_1 = first;
+    this.k2o_1 = last;
+    this.l2o_1 = chordGrade;
+    this.m2o_1 = heightM;
+    this.n2o_1 = riseGrade;
+    this.o2o_1 = fallGrade;
+    this.p2o_1 = straightness;
+    this.q2o_1 = stepM;
   }
-  protoOf(TunnelSpan).o2o = function () {
-    return this.g2o_1 * this.n2o_1;
+  protoOf(TunnelSpan).r2o = function () {
+    return this.j2o_1 * this.q2o_1;
   };
-  protoOf(TunnelSpan).p2o = function () {
-    return this.h2o_1 * this.n2o_1;
+  protoOf(TunnelSpan).s2o = function () {
+    return this.k2o_1 * this.q2o_1;
   };
   protoOf(TunnelSpan).toString = function () {
-    return 'TunnelSpan(first=' + this.g2o_1 + ', last=' + this.h2o_1 + ', chordGrade=' + this.i2o_1 + ', heightM=' + this.j2o_1 + ', riseGrade=' + this.k2o_1 + ', fallGrade=' + this.l2o_1 + ', straightness=' + this.m2o_1 + ', stepM=' + this.n2o_1 + ')';
+    return 'TunnelSpan(first=' + this.j2o_1 + ', last=' + this.k2o_1 + ', chordGrade=' + this.l2o_1 + ', heightM=' + this.m2o_1 + ', riseGrade=' + this.n2o_1 + ', fallGrade=' + this.o2o_1 + ', straightness=' + this.p2o_1 + ', stepM=' + this.q2o_1 + ')';
   };
   protoOf(TunnelSpan).hashCode = function () {
-    var result = this.g2o_1;
-    result = imul(result, 31) + this.h2o_1 | 0;
-    result = imul(result, 31) + getNumberHashCode(this.i2o_1) | 0;
-    result = imul(result, 31) + getNumberHashCode(this.j2o_1) | 0;
-    result = imul(result, 31) + getNumberHashCode(this.k2o_1) | 0;
+    var result = this.j2o_1;
+    result = imul(result, 31) + this.k2o_1 | 0;
     result = imul(result, 31) + getNumberHashCode(this.l2o_1) | 0;
     result = imul(result, 31) + getNumberHashCode(this.m2o_1) | 0;
     result = imul(result, 31) + getNumberHashCode(this.n2o_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.o2o_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.p2o_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.q2o_1) | 0;
     return result;
   };
   protoOf(TunnelSpan).equals = function (other) {
@@ -6804,15 +6860,9 @@
       return true;
     if (!(other instanceof TunnelSpan))
       return false;
-    if (!(this.g2o_1 === other.g2o_1))
-      return false;
-    if (!(this.h2o_1 === other.h2o_1))
-      return false;
-    if (!equals(this.i2o_1, other.i2o_1))
-      return false;
-    if (!equals(this.j2o_1, other.j2o_1))
+    if (!(this.j2o_1 === other.j2o_1))
       return false;
-    if (!equals(this.k2o_1, other.k2o_1))
+    if (!(this.k2o_1 === other.k2o_1))
       return false;
     if (!equals(this.l2o_1, other.l2o_1))
       return false;
@@ -6820,30 +6870,36 @@
       return false;
     if (!equals(this.n2o_1, other.n2o_1))
       return false;
+    if (!equals(this.o2o_1, other.o2o_1))
+      return false;
+    if (!equals(this.p2o_1, other.p2o_1))
+      return false;
+    if (!equals(this.q2o_1, other.q2o_1))
+      return false;
     return true;
   };
   function Stations(options) {
-    this.q2o_1 = options.j2p();
-    this.r2o_1 = options.k2p();
-    this.s2o_1 = options.l2p();
     this.t2o_1 = options.m2p();
+    this.u2o_1 = options.n2p();
+    this.v2o_1 = options.o2p();
+    this.w2o_1 = options.p2p();
   }
   function grade($this, z, i, j, stepM) {
     return i < 0 || j >= z.length ? NaN : (z[j] - z[i]) / ((j - i | 0) * stepM);
   }
   function judge($this, profile, a, b, entries, exits, options, stations) {
-    var w = stations.r2o_1;
-    var z = profile.n2p_1;
+    var w = stations.u2o_1;
+    var z = profile.q2p_1;
     var n = z.length;
-    var step = options.u2o_1;
+    var step = options.x2o_1;
     var length = (b - a | 0) * step;
-    if (length < options.g2p_1 - 1.0E-9)
+    if (length < options.j2p_1 - 1.0E-9)
       return null;
-    var chord = Distance_instance.n12(new LatLon(profile.o2p_1[a], profile.p2p_1[a]), new LatLon(profile.o2p_1[b], profile.p2p_1[b]));
+    var chord = Distance_instance.n12(new LatLon(profile.r2p_1[a], profile.s2p_1[a]), new LatLon(profile.r2p_1[b], profile.s2p_1[b]));
     var straightness = chord / length;
-    if (!(straightness >= options.i2p_1))
+    if (!(straightness >= options.l2p_1))
       return null;
-    var w0 = stations.r2o_1;
+    var w0 = stations.u2o_1;
     // Inline function 'kotlin.comparisons.maxOf' call
     var b_0 = a - w0 | 0;
     var inductionVariable = Math.max(0, b_0);
@@ -6874,7 +6930,7 @@
        while (!(k_0 === last));
     var c = (z[b] - z[a]) / length;
     // Inline function 'kotlin.math.abs' call
-    if (!(Math.abs(c) <= options.b2p_1))
+    if (!(Math.abs(c) <= options.e2p_1))
       return null;
     var height = -Infinity;
     var inductionVariable_1 = a;
@@ -6883,15 +6939,15 @@
         var k_1 = inductionVariable_1;
         inductionVariable_1 = inductionVariable_1 + 1 | 0;
         var h = z[k_1] - (z[a] + c * (k_1 - a | 0) * step);
-        if (isNaN_0(h) || h < -options.e2p_1)
+        if (isNaN_0(h) || h < -options.h2p_1)
           return null;
         if (h > height)
           height = h;
       }
        while (!(k_1 === b));
-    if (height < options.c2p_1)
+    if (height < options.f2p_1)
       return null;
-    var f = stations.t2o_1;
+    var f = stations.w2o_1;
     var nearEntry = -Infinity;
     var inductionVariable_2 = a;
     // Inline function 'kotlin.comparisons.minOf' call
@@ -6921,9 +6977,9 @@
         nearExit = Math.max(tmp0_1, b_5);
       }
        while (!(k_3 === b));
-    if (nearEntry < options.c2p_1 || nearExit < options.c2p_1)
+    if (nearEntry < options.f2p_1 || nearExit < options.f2p_1)
       return null;
-    var s = stations.s2o_1;
+    var s = stations.v2o_1;
     var rise = -Infinity;
     // Inline function 'kotlin.comparisons.maxOf' call
     var b_6 = a - (w / 2 | 0) | 0;
@@ -6955,7 +7011,7 @@
           fall = g_0;
       }
        while (!(k_5 === last_2));
-    if (rise < options.z2o_1 || fall > -options.z2o_1)
+    if (rise < options.c2p_1 || fall > -options.c2p_1)
       return null;
     // Inline function 'kotlin.collections.filter' call
     // Inline function 'kotlin.collections.filterTo' call
@@ -6992,7 +7048,7 @@
           do {
             var k_6 = inductionVariable_6;
             inductionVariable_6 = inductionVariable_6 + 1 | 0;
-            if (z[k_6] - (z[a] + c * (k_6 - a | 0) * step) < options.f2p_1)
+            if (z[k_6] - (z[a] + c * (k_6 - a | 0) * step) < options.i2p_1)
               return null;
           }
            while (!(k_6 === y));
@@ -7001,15 +7057,15 @@
     return new TunnelSpan(a, b, c, height, rise, fall, straightness, step);
   }
   function TunnelDetector() {
-    this.q2p_1 = 1.0E-6;
+    this.t2p_1 = 1.0E-6;
   }
-  protoOf(TunnelDetector).r2p = function (profile, options) {
-    var z = profile.n2p_1;
+  protoOf(TunnelDetector).u2p = function (profile, options) {
+    var z = profile.q2p_1;
     if (z.length < 2)
       return emptyList();
     var stations = new Stations(options);
-    var entries = this.s2p(z, options, true, stations);
-    var exits = this.s2p(z, options, false, stations);
+    var entries = this.v2p(z, options, true, stations);
+    var exits = this.v2p(z, options, false, stations);
     var out = ArrayList_init_$Create$();
     var next = -1;
     var _iterator__ex2g4s = entries.l();
@@ -7023,7 +7079,7 @@
         var b = _iterator__ex2g4s_0.n();
         if (b <= a)
           continue $l$loop_2;
-        if ((b - a | 0) * options.u2o_1 > options.h2p_1 + 1.0E-9)
+        if ((b - a | 0) * options.x2o_1 > options.k2p_1 + 1.0E-9)
           break $l$loop_2;
         var tmp0_elvis_lhs = judge(this, profile, a, b, entries, exits, options, stations);
         var tmp;
@@ -7033,23 +7089,23 @@
           tmp = tmp0_elvis_lhs;
         }
         var span = tmp;
-        if (best == null || span.j2o_1 > best.j2o_1 + 1.0E-9)
+        if (best == null || span.m2o_1 > best.m2o_1 + 1.0E-9)
           best = span;
       }
       if (!(best == null)) {
         // Inline function 'kotlin.collections.plusAssign' call
         var element = best;
         out.k(element);
-        next = best.h2o_1;
+        next = best.k2o_1;
       }
     }
     return out;
   };
-  protoOf(TunnelDetector).s2p = function (z, options, entry, stations) {
+  protoOf(TunnelDetector).v2p = function (z, options, entry, stations) {
     var n = z.length;
-    var m = stations.q2o_1;
-    var w = stations.r2o_1;
-    var step = options.u2o_1;
+    var m = stations.t2o_1;
+    var w = stations.u2o_1;
+    var step = options.x2o_1;
     var tmp = 0;
     var tmp_0 = new Float64Array(n);
     while (tmp < n) {
@@ -7072,14 +7128,14 @@
           var tmp_2;
           var tmp_3;
           // Inline function 'kotlin.math.abs' call
-          if (Math.abs(back) <= options.x2o_1) {
+          if (Math.abs(back) <= options.a2p_1) {
             // Inline function 'kotlin.math.abs' call
-            tmp_3 = Math.abs(outer) <= options.x2o_1;
+            tmp_3 = Math.abs(outer) <= options.a2p_1;
           } else {
             tmp_3 = false;
           }
           if (tmp_3) {
-            tmp_2 = ahead >= options.y2o_1;
+            tmp_2 = ahead >= options.b2p_1;
           } else {
             tmp_2 = false;
           }
@@ -7089,14 +7145,14 @@
           var tmp_4;
           var tmp_5;
           // Inline function 'kotlin.math.abs' call
-          if (Math.abs(ahead) <= options.x2o_1) {
+          if (Math.abs(ahead) <= options.a2p_1) {
             // Inline function 'kotlin.math.abs' call
-            tmp_5 = Math.abs(outer_0) <= options.x2o_1;
+            tmp_5 = Math.abs(outer_0) <= options.a2p_1;
           } else {
             tmp_5 = false;
           }
           if (tmp_5) {
-            tmp_4 = back <= -options.y2o_1;
+            tmp_4 = back <= -options.b2p_1;
           } else {
             tmp_4 = false;
           }
@@ -7172,30 +7228,30 @@
     return TunnelDetector_instance;
   }
   function TunnelProfile(terrainM, latDeg, lonDeg) {
-    this.n2p_1 = terrainM;
-    this.o2p_1 = latDeg;
-    this.p2p_1 = lonDeg;
+    this.q2p_1 = terrainM;
+    this.r2p_1 = latDeg;
+    this.s2p_1 = lonDeg;
     // Inline function 'kotlin.require' call
-    if (!(this.n2p_1.length === this.o2p_1.length && this.o2p_1.length === this.p2p_1.length)) {
-      var message = 'terrain, latitude and longitude must have one sample per station: ' + this.n2p_1.length + ', ' + this.o2p_1.length + ', ' + this.p2p_1.length;
+    if (!(this.q2p_1.length === this.r2p_1.length && this.r2p_1.length === this.s2p_1.length)) {
+      var message = 'terrain, latitude and longitude must have one sample per station: ' + this.q2p_1.length + ', ' + this.r2p_1.length + ', ' + this.s2p_1.length;
       throw IllegalArgumentException_init_$Create$_0(toString_0(message));
     }
   }
   function stations_0($this, metres, name) {
-    var r = metres / $this.u2o_1;
+    var r = metres / $this.x2o_1;
     var k = roundToInt(r);
     // Inline function 'kotlin.math.abs' call
     var x = r - k;
     // Inline function 'kotlin.require' call
     if (!(Math.abs(x) < 1.0E-9)) {
-      var message = name + ' = ' + metres + ' m is not a whole number of ' + $this.u2o_1 + ' m stations';
+      var message = name + ' = ' + metres + ' m is not a whole number of ' + $this.x2o_1 + ' m stations';
       throw IllegalArgumentException_init_$Create$_0(toString_0(message));
     }
     return k;
   }
   function Companion_10() {
     Companion_instance_11 = this;
-    this.t2p_1 = new TunnelDetectorOptions();
+    this.w2p_1 = new TunnelDetectorOptions();
   }
   var Companion_instance_11;
   function Companion_getInstance_10() {
@@ -7220,85 +7276,82 @@
     minLengthM = minLengthM === VOID ? 50.0 : minLengthM;
     maxLengthM = maxLengthM === VOID ? 3000.0 : maxLengthM;
     minStraightness = minStraightness === VOID ? 0.8 : minStraightness;
-    this.u2o_1 = stepM;
-    this.v2o_1 = footWindowM;
-    this.w2o_1 = steepWindowM;
-    this.x2o_1 = maxRoadGrade;
-    this.y2o_1 = minPortalGrade;
-    this.z2o_1 = minSideGrade;
-    this.a2p_1 = sideSearchM;
-    this.b2p_1 = maxChordGrade;
-    this.c2p_1 = minHeightM;
-    this.d2p_1 = faceReachM;
-    this.e2p_1 = maxBelowChordM;
-    this.f2p_1 = minValleyHeightM;
-    this.g2p_1 = minLengthM;
-    this.h2p_1 = maxLengthM;
-    this.i2p_1 = minStraightness;
+    this.x2o_1 = stepM;
+    this.y2o_1 = footWindowM;
+    this.z2o_1 = steepWindowM;
+    this.a2p_1 = maxRoadGrade;
+    this.b2p_1 = minPortalGrade;
+    this.c2p_1 = minSideGrade;
+    this.d2p_1 = sideSearchM;
+    this.e2p_1 = maxChordGrade;
+    this.f2p_1 = minHeightM;
+    this.g2p_1 = faceReachM;
+    this.h2p_1 = maxBelowChordM;
+    this.i2p_1 = minValleyHeightM;
+    this.j2p_1 = minLengthM;
+    this.k2p_1 = maxLengthM;
+    this.l2p_1 = minStraightness;
     // Inline function 'kotlin.require' call
-    if (!(this.u2o_1 > 0.0)) {
-      var message = 'stepM must be positive, got ' + this.u2o_1;
+    if (!(this.x2o_1 > 0.0)) {
+      var message = 'stepM must be positive, got ' + this.x2o_1;
       throw IllegalArgumentException_init_$Create$_0(toString_0(message));
     }
     // Inline function 'kotlin.require' call
-    if (!(this.j2p() >= 1 && this.k2p() >= 1)) {
+    if (!(this.m2p() >= 1 && this.n2p() >= 1)) {
       var message_0 = 'grade windows must cover a station';
       throw IllegalArgumentException_init_$Create$_0(toString_0(message_0));
     }
     // Inline function 'kotlin.require' call
-    if (!(this.l2p() >= 0)) {
+    if (!(this.o2p() >= 0)) {
       var message_1 = 'negative sideSearchM';
       throw IllegalArgumentException_init_$Create$_0(toString_0(message_1));
     }
     // Inline function 'kotlin.require' call
-    if (!(this.m2p() >= 1)) {
+    if (!(this.p2p() >= 1)) {
       var message_2 = 'faceReachM must cover a station';
       throw IllegalArgumentException_init_$Create$_0(toString_0(message_2));
     }
     // Inline function 'kotlin.require' call
-    if (!(this.x2o_1 >= 0.0 && this.y2o_1 > 0.0 && this.z2o_1 > 0.0)) {
+    if (!(this.a2p_1 >= 0.0 && this.b2p_1 > 0.0 && this.c2p_1 > 0.0)) {
       var message_3 = 'grades must be positive';
       throw IllegalArgumentException_init_$Create$_0(toString_0(message_3));
     }
     // Inline function 'kotlin.require' call
-    if (!(this.b2p_1 >= 0.0 && this.c2p_1 > 0.0 && this.e2p_1 >= 0.0)) {
+    if (!(this.e2p_1 >= 0.0 && this.f2p_1 > 0.0 && this.h2p_1 >= 0.0)) {
       var message_4 = 'negative threshold';
       throw IllegalArgumentException_init_$Create$_0(toString_0(message_4));
     }
-    var containsUpper = this.h2p_1;
-    var containsArg = this.g2p_1;
+    var containsUpper = this.k2p_1;
+    var containsArg = this.j2p_1;
     // Inline function 'kotlin.require' call
     if (!(0.0 <= containsArg ? containsArg <= containsUpper : false)) {
       var message_5 = 'minLengthM must be in 0..maxLengthM';
       throw IllegalArgumentException_init_$Create$_0(toString_0(message_5));
     }
-    var containsArg_0 = this.i2p_1;
+    var containsArg_0 = this.l2p_1;
     // Inline function 'kotlin.require' call
     if (!(0.0 <= containsArg_0 ? containsArg_0 <= 1.0 : false)) {
-      var message_6 = 'minStraightness must be in 0..1, got ' + this.i2p_1;
+      var message_6 = 'minStraightness must be in 0..1, got ' + this.l2p_1;
       throw IllegalArgumentException_init_$Create$_0(toString_0(message_6));
     }
   }
-  protoOf(TunnelDetectorOptions).j2p = function () {
-    return stations_0(this, this.v2o_1, 'footWindowM');
+  protoOf(TunnelDetectorOptions).m2p = function () {
+    return stations_0(this, this.y2o_1, 'footWindowM');
   };
-  protoOf(TunnelDetectorOptions).k2p = function () {
-    return stations_0(this, this.w2o_1, 'steepWindowM');
+  protoOf(TunnelDetectorOptions).n2p = function () {
+    return stations_0(this, this.z2o_1, 'steepWindowM');
   };
-  protoOf(TunnelDetectorOptions).l2p = function () {
-    return stations_0(this, this.a2p_1, 'sideSearchM');
+  protoOf(TunnelDetectorOptions).o2p = function () {
+    return stations_0(this, this.d2p_1, 'sideSearchM');
   };
-  protoOf(TunnelDetectorOptions).m2p = function () {
-    return stations_0(this, this.d2p_1, 'faceReachM');
+  protoOf(TunnelDetectorOptions).p2p = function () {
+    return stations_0(this, this.g2p_1, 'faceReachM');
   };
   protoOf(TunnelDetectorOptions).toString = function () {
-    return 'TunnelDetectorOptions(stepM=' + this.u2o_1 + ', footWindowM=' + this.v2o_1 + ', steepWindowM=' + this.w2o_1 + ', maxRoadGrade=' + this.x2o_1 + ', minPortalGrade=' + this.y2o_1 + ', minSideGrade=' + this.z2o_1 + ', sideSearchM=' + this.a2p_1 + ', maxChordGrade=' + this.b2p_1 + ', minHeightM=' + this.c2p_1 + ', faceReachM=' + this.d2p_1 + ', maxBelowChordM=' + this.e2p_1 + ', minValleyHeightM=' + this.f2p_1 + ', minLengthM=' + this.g2p_1 + ', maxLengthM=' + this.h2p_1 + ', minStraightness=' + this.i2p_1 + ')';
+    return 'TunnelDetectorOptions(stepM=' + this.x2o_1 + ', footWindowM=' + this.y2o_1 + ', steepWindowM=' + this.z2o_1 + ', maxRoadGrade=' + this.a2p_1 + ', minPortalGrade=' + this.b2p_1 + ', minSideGrade=' + this.c2p_1 + ', sideSearchM=' + this.d2p_1 + ', maxChordGrade=' + this.e2p_1 + ', minHeightM=' + this.f2p_1 + ', faceReachM=' + this.g2p_1 + ', maxBelowChordM=' + this.h2p_1 + ', minValleyHeightM=' + this.i2p_1 + ', minLengthM=' + this.j2p_1 + ', maxLengthM=' + this.k2p_1 + ', minStraightness=' + this.l2p_1 + ')';
   };
   protoOf(TunnelDetectorOptions).hashCode = function () {
-    var result = getNumberHashCode(this.u2o_1);
-    result = imul(result, 31) + getNumberHashCode(this.v2o_1) | 0;
-    result = imul(result, 31) + getNumberHashCode(this.w2o_1) | 0;
-    result = imul(result, 31) + getNumberHashCode(this.x2o_1) | 0;
+    var result = getNumberHashCode(this.x2o_1);
     result = imul(result, 31) + getNumberHashCode(this.y2o_1) | 0;
     result = imul(result, 31) + getNumberHashCode(this.z2o_1) | 0;
     result = imul(result, 31) + getNumberHashCode(this.a2p_1) | 0;
@@ -7310,6 +7363,9 @@
     result = imul(result, 31) + getNumberHashCode(this.g2p_1) | 0;
     result = imul(result, 31) + getNumberHashCode(this.h2p_1) | 0;
     result = imul(result, 31) + getNumberHashCode(this.i2p_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.j2p_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.k2p_1) | 0;
+    result = imul(result, 31) + getNumberHashCode(this.l2p_1) | 0;
     return result;
   };
   protoOf(TunnelDetectorOptions).equals = function (other) {
@@ -7317,12 +7373,6 @@
       return true;
     if (!(other instanceof TunnelDetectorOptions))
       return false;
-    if (!equals(this.u2o_1, other.u2o_1))
-      return false;
-    if (!equals(this.v2o_1, other.v2o_1))
-      return false;
-    if (!equals(this.w2o_1, other.w2o_1))
-      return false;
     if (!equals(this.x2o_1, other.x2o_1))
       return false;
     if (!equals(this.y2o_1, other.y2o_1))
@@ -7347,6 +7397,12 @@
       return false;
     if (!equals(this.i2p_1, other.i2p_1))
       return false;
+    if (!equals(this.j2p_1, other.j2p_1))
+      return false;
+    if (!equals(this.k2p_1, other.k2p_1))
+      return false;
+    if (!equals(this.l2p_1, other.l2p_1))
+      return false;
     return true;
   };
   //region block: init