srecord noeq G22MeshMapper_v2(G22Mesh mesh1, G22Mesh mesh2) {

  // import the important classes

  delegate Anchor, Curve to G22Mesh.

  delegate mapAnchor, unmapAnchor, tempMapAnchor to mm.

  // params

  settable bool chooseAnchor1AtRandom;

  // output

  G22MeshMapping mm;

  // 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; }

  // Do the whole search, but in "random" mode (may fail)

  void run_random {

    search_step1();

    while (search_step2());

  }

  // random mode

  void search_step1() {

    prechecks(); if (rejected()) ret;

    // 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)

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

    // Choose which anchor to map it to 

    // (first backtracking point)

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

    // ret BacktrackingOptions(options, ...); ???

    Anchor anchor2 = random(options);

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

    mapAnchor(anchor1, anchor2);

  }

  // random mode

  bool search_step2() {

    bool change;

    for (curve1 : mesh1.curves()) {

      // skip if curve is already mapped

      if (mm.isMapped(curve1))

        continue; // with print("Curve is mapped: " + curve1);

      print("Looking to match " + curve1);

      // 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)

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

      // 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);

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

      print(+a1);

      print(+a2);

      print(+a1other);

      new L<Curve> possibleCurves;

      for (c2 : a2.curves()) {

        if (mm.isMapped(c2))

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

        // check for arity match

        Anchor a3 = c2.anchorOpposite(a2);

        print(+a3);

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

        if (arity1 != arity2)

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

        // This curve is viable as a mapping target

        possibleCurves.add(c2);

      }

      print(l(possibleCurves) + "/" + l(a2.curves())

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

      pnl(possibleCurves);

      if (empty(possibleCurves))

        ret false with rejectedBecause("Could not map curve " + curve1);

      // Map the curve

      Curve c2 = random(possibleCurves);

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

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

      mm.mapCurve(curve1, c2, flipped);

      set change;

    }

    ret change;

  }

  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);

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

        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, c2;

    Anchor a2;

    public selfType makeEmptyClone() { ret new selfType; }

    void step(VStack stack) {

      cast stack to BStack<?>;

      if (step == 0) {

        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

        if (mm.isMapped(curve1)) {

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

          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;

        }

        // 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);

        new L<Curve> possibleCurves;

        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

          possibleCurves.add(c2);

          print("Possible curve!");

        }

        print(l(possibleCurves) + "/" + l(a2.curves())

          + " 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 {

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

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

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

        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);

  }

}