anchor.diff:        | (_, cs :: []) ->
           [
             cs
  -          |> List.rev
  -          |> Seq.skip 1
  -          |> Seq.toList
  -          |> List.rev
  -          |> List.fold (fun  s0 c -> c.NextState(s0)) s
  +          |> Seq.truncate (List.length cs - 1)
  +          |> Seq.fold (fun  s0 c -> c.NextState(s0)) s
           ]
         | _ ->
           let inits = css |> scan (fun cs x -> ((List.head cs).NextState(s), (List.tail cs) :: x))
  
positive.code:         else
            let rs =
              cs
              |> List.rev
              |> Seq.skip 1
              |> Seq.toList
              |> List.rev
              |> List.map (Command.runPC sut >> fst)
            let r, pf = Command.runPC sut (Seq.last cs)
            (Prop.atLeastOne (endStates |> List.map pf), List.zip cs (List.rev (r :: List.rev rs)))
  
negative.code:   )
  
    let runSeqCmds (sut: 'Sut) (s0: 'State) (cs: Commands<'Sut, 'State, 'Result>) =
      (cs, (Prop.proved.Value, s0, []))
      ||> List.foldBack (fun c (p, s, rs) ->
        let r, pf = Command.runPC sut c
        (p .&. lazy (pf s), c.NextState(s), r :: rs))
  
    let rec private scan (f: _ -> _ -> _) xs =
      let rec inner acc f = function
      | [] -> acc
      | y::ys -> inner (f y ys :: acc) (fun x xs -> f x (y::xs)) ys
      inner [] f xs
  
    let runParCmds (sut: 'Sut) (s: 'State) (pcmds: Commands<_, _, 'Result> list) =
      let memo = Dictionary<'State * Commands<'Sut, 'State, 'Result> list, 'State list>()
  