srecord noeq G22MeshMapper_v2(G22Mesh mesh1, G22Mesh mesh2) {

  // import the important classes

  delegate Anchor, Curve to G22Mesh.

  delegate mapAnchor, unmapAnchor, tempMapAnchor to mm.

  delegate MappedCurve to G22MeshMapping.

  // params

  settable bool chooseAnchor1AtRandom;

  // output

  G22MeshMapping mm;

  settable L debugOutput;

  // for visualization

  settable float contrast = 0.25f;

  settable int brightness = 128;

  // index structures

  MultiMap<Int, Anchor> anchorsByArity2;

  // EXCEPTIONS (e.g. meshes don't match in signature)

  // set to the reason why when a mapping is deemed impossible

  settable O rejectedBecause;

  bool rejected() { ret rejectedBecause != null; }

  // INTERNAL VARS

  bool prechecksDone;

  S sig1, sig2;

  Anchor anchor1; // first anchor to map

  G22MeshMapping get() { ret mm; }

  Search newSearch() {

    ret new Search;

  }

  // backtracking version

  class Search extends VStackComputableWithStep<Void> is IMakeEmptyClone {

    Anchor anchor2;

    public selfType makeEmptyClone() { ret new selfType; }

    void step(VStack stack) {

      cast stack to BStack<?>;

      if (step == 0) {

        prechecks();

        if (rejected()) stack.ret();

        step = 1;

      } else if (step == 1) {

        // make empty mapping

        mm = new G22MeshMapping(mesh1, mesh2);

        anchorsByArity2 = multiMapIndex(mesh2.anchors(), a -> a.arity());

        // Choose first anchor to map - this is arbitrary

        // (not a backtracking point)

        anchor1 = chooseAnchor1AtRandom ? random(mesh1.anchors()) : first(mesh1.anchors());

        // Choose which anchor to map it to (first backtracking point).

        // List should never be empty because we checked the signatures first.

        L<Anchor> anchor2options = anchorsByArity2.get(anchor1.arity());

        step = 2;

        stack.options(this, map(anchor2options, anchor2

          -> instance -> instance.anchor2 = anchor2));

      } else if (step == 2) {

        print("G22MeshMapper_v2 step1: Connecting " + anchor1 + " to " + anchor2);

        add(debugOutput, "Mapping anchor");

        stack.temp(tempMapAnchor(anchor1, anchor2));

        stack.temp(-> add(debugOutput, print("Unmapping anchor")));

        addMappingToDebugOutput();

        step = 3;

      } else if (step == 3) {

        stack.call(new Step2);

        step = 4;

      } else {

        if (isTrue(stack.subResult()))

          step = 3;

        else

          stack.return();

      }

    }

  }

  class Step2 extends VStackComputableWithStep<Bool> is IMakeEmptyClone {

    bool change;

    Iterator<Curve> curve1iterator;

    Curve curve1;

    MappedCurve c2;

    Anchor a2;

    public selfType makeEmptyClone() { ret new selfType; }

    void step(VStack stack) {

      cast stack to BStack<?>;

      if (step == 0) {

        print(n2(mesh1.curves(), "curve") + " in mesh1, mapped: " + l(mm.curveMap));

        print("mesh1.curves: " + map identityHashCode(mesh1.curves()));

        print("mapped: " + map identityHashCode(keys(mm.curveMap)));

        print("mapped (backward map): " + map identityHashCode(keys(mm.curveBackwardMap)));

        curve1iterator = iterator(mesh1.curves());

        step++;

      } else if (step == 1) {

        if (!curve1iterator.hasNext())

          ret with stack.return(change);

        curve1 = curve1iterator.next();

        print("Looking to match " + curve1);

        // skip if curve is already mapped

        MappedCurve curve1mapping = mm.get(curve1);

        if (curve1mapping != null) {

          print("Curve is mapped: " + curve1);

          assertTrue("mesh2 contains curve1mapping", mesh2.containsCurve(curve1mapping!));

          ret; // continue loop

        }

        // check if anchors are mapped

        Anchor start2 = mm.get(curve1.start);

        Anchor end2 = mm.get(curve1.end);

        // If neither anchor is mapped, postpone this curve

        if (start2 == null && end2 == null) {

          //print("Curve is not discovered yet: " + curve1);

          ret; // continue loop;

        }

        new L<MappedCurve> possibleCurves;

        if (start2 != null && end2 != null) {

          // Both anchors are mapped already, choose

          // one the curves connecting them in mesh2.

          for (curve2 : start2.curves())

            if (curve2.connectedTo(end2)) {

              bool flipped = curve2.end == start2;

              possibleCurves.add(new MappedCurve(curve2, flipped));

            }

        } else {

          // Only one anchor is mapped.

          // Start at the mapped anchor, choose a viable curve in mesh2 to map to

          bool startAtEnd = end2 != null;

          Anchor a1 = curve1.anchor(startAtEnd);

          Anchor a1other = curve1.anchor(!startAtEnd);

          a2 = mm.get(curve1.anchor(startAtEnd));

          print(+a1);

          print(+a2);

          print(+a1other);

          for (c2 : a2.curves()) {

            if (mm.isMapped(c2)) {

              //print("Curve already mapped: " + c2);

              continue; // continue loop

            }

            // check for arity match

            Anchor a3 = c2.anchorOpposite(a2);

            print(+a3);

            int arity1 = a3.arity(), arity2 = a1other.arity();

            if (arity1 != arity2) {

              print("Arity mismatch (" + arity1 + "/" + arity2 + ") for curve " + c2);

              continue; // continue loop

            }

            // This curve is viable as a mapping target

            bool flipped = c2.start() != a2;

            possibleCurves.add(new MappedCurve(c2, flipped));

            print("Possible curve!");

          }

        }

        addPossibleCurvesToDebugOutput(curve1, possibleCurves);

        print(l(possibleCurves)

          + " possible curve(s) to map " + curve1 + " to: ");

        pnl(possibleCurves);

        if (empty(possibleCurves)) {

          stack.temp(tempRejectedBecause("Could not map curve " + curve1));

          ret with stack.ret(false);

        }

        // Go through all curve mappings

        step = 2;

        stack.options(this, map(possibleCurves,

          c2 -> instance -> instance.c2 = c2));

        ret;

      } else {

        print("Mapping curve " + curve1 + " to " + c2);

        add(debugOutput, print("Mapping curve"));

        stack.temp(mm.tempMapCurve(curve1, c2!, c2.flipped));

        stack.temp(-> add(debugOutput, "Unmapping curve"));

        addMappingToDebugOutput();

        set change;

        // continue loop

        step = 1;

      }

    }

  }

  protected void prechecks {

    set prechecksDone;

    sig1 = mesh1.signature();

    sig2 = mesh1.signature();

    if (!eq(sig1, sig2))

      ret with rejectedBecause(G22SignatureMismatch(mesh1, mesh2));

  }

  AutoCloseable tempRejectedBecause(O reason) {

    rejectedBecause(reason);

    ret -> rejectedBecause(null);

  }

  void addMappingToDebugOutput() {

    if (debugOutput == null) ret;

    O error = mm.validityError();

    addIfNotNull(debugOutput, error);

    // use full meshes as background

    var img1 = mesh1.getBufferedImage();

    var img2 = mesh2.getBufferedImage();

    for (img : ll(img1, img2))

      bufferedImageContrastAndBrightness(img, contrast, brightness);

    mm.drawMappedPartOfMesh1(createGraphics(img1));

    mm.drawMappedPartOfMesh2(createGraphics(img2));

    addPair(debugOutput, img1, img2);

  }

  void addPossibleCurvesToDebugOutput(Curve c1, Cl<MappedCurve> possibleCurves) {

    if (debugOutput == null) ret;

    // use full meshes as background

    var img1 = mesh1.getBufferedImage();

    var img2 = mesh2.getBufferedImage();

    for (img : ll(img1, img2))

      bufferedImageContrastAndBrightness(img, contrast, brightness);

    new G22VisualizeMeshes().drawCurve(createGraphics(img1), c1);  

    for (curve : possibleCurves) {

      new G22VisualizeMeshes vm;

      if (curve.flipped)

        vm.curveColor(Color.green);

      vm.drawCurve(createGraphics(img2), curve!);

    }

    add(debugOutput, n2(possibleCurves, "possible curve"));

    addPair(debugOutput, img1, img2);

  }

}