srecord noeq G22MeshMapper(G22Mesh mesh1, G22Mesh mesh2) > AbstractSteppable {
  // import the important classes
  delegate Anchor, Curve to G22Mesh.
  
  // MAPPING VARS
  
  // keys are the anchors from mesh1, values are the anchors from mesh2
  new Map<Anchor> anchorMap;
  
  // keys are the curves from mesh1, values are the curves from mesh2
  new Map<Curve> mappedCurves;
  
  // 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;
  
  // Anchors and curves in mesh1 that are not or only partially mapped.
  // This list is not complete at the beginning. Anchors and curves are
  // discovered by searching breadth-first from the visited anchors and
  // curves.
  new L<Anchor> mappableAnchors;
  
  // curves that are half-mapped (one end is mapped) indexed by the
  // unmapped anchor
  new MultiMap<Anchor, Curve> halfMappedCurves;
  
  // anchor lookup mesh 1
  // MultiMap<Int, Anchor> anchorsByArity1;
  
  // anchor lookup mesh 2
  MultiMap<Int, Anchor> anchorsByArity2;
  
  // First let's define the search procedure in a "normal" (native)
  // control flow. Then possibly convert to v-stack/coroutine.
  
  void searchForMapping {
    prechecks(); if (rejected()) ret;
    anchorsByArity2 = multiMapIndex(mesh2.anchors(), a -> a.arity());
    
    Anchor anchor1 = first(mesh1.anchors());
    for (anchor2 : anchorsByArity2.get(anchor1.arity())) {
      temp tempAssignAnchor(anchor1, anchor2);
      
      //while (nempty(mappableCurves))
    }
  }
  
  AutoCloseable tempAssignAnchor(Anchor anchor1, Anchor anchor2) {
    var undoAnchorAssignment = tempMapPutStrictlyOrFail(anchorMap, anchor1, anchor2);
    
    // Check all curves connected to anchor1. They will now be at least
    // half mapped.
    for (curve : anchor1.curves()) {
      Curve curve2 = calculateCurveMapping(curve);
      if (curve2 != null) {
        halfMappedCurves.remove(anchor1, curve);
        mappedCurves.put(curve, curve2);
      } else
        halfMappedCurves.put(curve.anchorOpposite(anchor1), curve);
    }
    
    ret -> {
      _close(undoAnchorAssignment);
      
      for (curve : anchor1.curves()) {
        mappedCurves.remove(curve);
        if (nCurveAnchorsAssigned(curve) == 0) {
          halfMappedCurves.remove(anchor1, curve);
        }
      }
    };
  }
  
  int nCurveAnchorsAssigned(Curve curve1) {
    // count twice if stat+end is same anchor
    ret zeroOrOne(anchorMap.containsKey(curve1.start()))
      + zeroOrOne(anchorMap.containsKey(curve1.end()));
  }
  
  Curve calculateCurveMapping(Curve curve1) {
    fail();
    // TODO: there are possibly multiple choices here!
  }
  
  public bool step() {
    if (!prechecksDone) {
      prechecks();
      ret !rejected();
    }
    
    false; // TODO
  }
  
  protected void prechecks {
    set prechecksDone;
    sig1 = mesh1.signature();
    sig2 = mesh1.signature();
    if (!eq(sig1, sig2))
      ret with rejectedBecause(G22SignatureMismatch(mesh1, mesh2));
  }
}