anchor.diff:          let childPos = List.nth sizes idx
           let childExp = List.nth exprs idx
           rcr childExp tl childPos
  -  e, rcr e moves 0
  +  e, s, rcr e moves 0
   
   let movesUpdate (p: Move list) (nextMove: Move): Move list =
     p |> List.iter (fun m -> assert(m <> Up))
  
positive.code:   | _  -> p @ [nextMove]
  
  let stepProg (prog: ProgramState) (step: Step): ProgramState = 
    let (e, pos) = prog
    match step with 
    | StepMove(m) -> 
      let (_, moves) = stateToMoves prog
      let moves' = movesUpdate moves m
      movesToState (e, moves')
    | StepRule(r) ->
      applyRuleAtParticularPosition e (pos, r), pos
  
  let deltaPos (p1: Move list) (p2: Move list): Move list = 
    let rec commonPrefix l1 l2 = 
  
negative.code:           rcr exp childPos
    rcr e zeroMetaData
  
  let subexpr ((e, s, pos) as state: ProgramState): Expr = 
    match s with 
    | Some(se) -> se
    | None -> positionToSubexpr e pos
  
  
  
  let stateToMoves ((e, s, pos) as state: ProgramState): ProgramMoves = 
    e, s, positionToMoves e pos
  
  let stateToExternal (rs: Rule list) (state: ProgramState) : ProgramExternalState = 
    let rules = examineAllRulesPositioned rs (subexpr state) |> List.filter (fun r -> (fst r) = 0) |> List.map (fun i -> snd (snd i)) |> Set.ofList
    let (_, _, moves) = stateToMoves state
    let currentDepth = moves |> List.length
    rules, currentDepth
  
  let externalToString (rulesIndexMap: Map<RuleInfo, int>) (ext: ProgramExternalState): string = 
  