srecord noeq G22_RegionToSSIs_v2(IImageRegion region) extends Meta {

  Color color;

  L<SSI> ssis;

  new L<GrowingSSI> growingSSIs;

  settable bool withDiagonals;

  settable bool checkCoherence = true;

  settable bool checkStreaks = true;

  private int x1, y;

  class GrowingSSI {

    settable int y1;

    new ShortBuffer data;

    int y2() { ret y1+l(data)/2; }

    SSI finish() {

      ret addAndReturn(ssis, new SSI(y1, y2()).data(data.toArray())

        .color(color));

    }

    bool isEmpty() { ret data.isEmpty(); }

    int lastx1() { ret data.get(l(data)-2); }

    int lastx2() { ret data.get(l(data)-1); }

    IntRange lastRange() { ret isEmpty() ? null : intRange(lastx1(), lastx2()); }

    // can add this line without breaking coherence?

    bool canAdd(IntRange r) {

      ret isEmpty()

        || intRangesOverlapNempty(r.start, r.end, lastx1()-diag(), lastx2()+diag());

    }

    void add(IntRange r) {

      if (checkCoherence() && !canAdd(r))

        fail("Coherence fail", +lastx1(), +lastx2(), +r);

      data.add(toShort_enforce(r.start));

      data.add(toShort_enforce(r.end));

    }

  }

  void finishSSI(int iSSI) {

    growingSSIs.remove(iSSI).finish();

  }

  private GrowingSSI startSSI(int iSSI default l(growingSSIs), IntRange range) {

    if (scaffoldingEnabled()) printVars("startSSI", +iSSI, +range);

    var ssi = new GrowingSSI().y1(y);

    ssi.add(range);

    ret addAndReturn(growingSSIs, iSSI, ssi);

  }

  L<IntRange> lastStreaks() {

    ret reallyLazyMap(growingSSIs, -> .lastRange());

  }

  int diag() { ret withDiagonals ? 1 : 0; }

  L<SSI> get() {

    if (region == null) null;

    color = region.color();

    ssis = new L;

    Rect r = region.bounds();

    int x1 = this.x1 = r.x1(), y1 = r.y1(), y2 = r.y2(), h = y2-y1, w = r.w;

    bool scaff = scaffoldingEnabled();

    for (y = y1; y < y2; y++) {

      reMutable y;

      L<IntRange> streaks = shiftIntRanges(x1, genericStreaks(w, x -> region.contains(x1+x, y)));

      var lastStreaks = lastStreaks();

      if (checkStreaks())

        assertProperStreaks(lastStreaks);

      // advance iSSI & iStreak simultaneously

      int iStreak = 0, iSSI = 0;

      int nStreaks = l(streaks);

      if (scaff) printVars(+y, +lastStreaks, +streaks);

      while ping (iStreak < nStreaks) {

        var range = streaks.get(iStreak);

        var ssi = _get(growingSSIs, iSSI);

        if (scaff) printVars(+y, +iStreak, +iSSI, +range, ssi := ssi?.lastRange());

        // case 1:

        //           ------

        // -------

        //

        // case 2:

        //

        // -------

        // (left of current SSI or to the right of everything)

        if (ssi == null || range.end <= ssi.lastx1()-diag()) {

          startSSI(iSSI++, range);

          ++iStreak;

          continue;

        }

        // Now we know that we have another SSI.

        // case 3:

        // -------

        //          ------

        // (Just end current SSI and do streak again.)

        if (range.start >= ssi.lastx2()+diag()) {

          finishSSI(iSSI);

          continue;

        }

        // Now we know the streak and the SSI overlap.

        // Find out if we have a choice on the top or on the bottom.

        // Check choices for streak

        int jStreak = iStreak+1;

        while (jStreak < nStreaks && ssi.canAdd(streaks.get(jStreak)))

          ++jStreak;

        // Check choices for SSI

        int jSSI = iSSI+1;

        while (jSSI < l(growingSSIs) && growingSSIs.get(jSSI).canAdd(range))

          ++jSSI;

        int nSSI = jSSI-iSSI, nStreak = jStreak-iStreak;

        if (scaff) printVars(+nSSI, +nStreak);

        new Best<Int> best;

        if (nSSI > 1) {

          if (nStreak > 1)

            fail("ANOMALY", +nSSI, +nStreak,

              ssis := subList(lastStreaks(), iSSI, jSSI),

              streaks := subList(streaks, iStreak, jStreak));  

          // Choose longest SSI

          for (int idx = iSSI; idx < jSSI; idx++)

            best.put(idx, l(growingSSIs.get(idx).lastRange()));

          jSSI = best!;

          while (jSSI-- > iSSI) finishSSI(iSSI);

        } else if (nStreak > 1) {

          // Choose longest streak

          for (int idx = iStreak; idx < jStreak; idx++)

            best.put(idx, l(streaks.get(idx)));

          jStreak = best!;

          while (iStreak < jStreak)

            startSSI(iSSI++, streaks.get(iStreak++));

        }

        // add line to SSI

        growingSSIs.get(iSSI++).add(streaks.get(iStreak++));

      }

      // remaining SSIs are unpaired, close them

      while (iSSI < l(growingSSIs)) finishSSI(iSSI);

    }

    // finish all remaining SSIs

    for (ssi : cloneAndClear(growingSSIs)) ssi.finish();

    ret ssis;

  }

}