anchor.diff:              | Some index -> this.SetCursor index model
               | None -> ()
   
  -    member this.OpenPath path cursor (model: MainModel) =
  -        try
  -            let newPath = fileSys.Normalize path
  -            let nodes = fileSys.GetNodes newPath
  -            model.BackStack <- (model.Path, model.Cursor) :: model.BackStack
  -            model.ForwardStack <- []
  -            model.Path <- newPath
  -            model.Nodes <- nodes
  -            model.Cursor <- cursor
  -            model.Status <- ""
  -        with | ex -> model.SetExceptionStatus ex "open path"
  -
  -    member this.SelectedPath (model: MainModel) =
  -        let path = model.SelectedNode.Path
  -        match model.SelectedNode.Type with
  -        | Folder | Drive | Error ->
  -            this.OpenPath path 0 model
  -        | File ->
  -            fileSys.OpenFile path
  -            model.Status <- "Opened File: " + path.Value
  -
  -    member this.ParentPath (model: MainModel) =
  -        let oldPath = model.Path
  -        this.OpenPath (fileSys.Parent model.Path) 0 model
  -        match model.Nodes |> Seq.tryFindIndex (fun n -> n.Path = oldPath) with
  -            | Some index -> model.Cursor <- index
  -            | None -> ()
  -
  -    member this.Back (model: MainModel) =
  -        match model.BackStack with
  -        | (path, cursor) :: backTail ->
  -            let newForwardStack = (model.Path, model.Cursor) :: model.ForwardStack
  -            this.OpenPath path cursor model
  -            model.BackStack <- backTail
  -            model.ForwardStack <- newForwardStack
  -        | [] -> ()
  -
  -    member this.Forward (model: MainModel) =
  -        match model.ForwardStack with
  -        | (path, cursor) :: forwardTail ->
  -            this.OpenPath path cursor model
  -            model.ForwardStack <- forwardTail
  -        | [] -> ()
  -
  -    member this.StartInput (inputMode: CommandInput) (model: MainModel) =
  -        if inputMode.AllowedOnNodeType model.SelectedNode.Type then
  -            model.CommandInputMode <- Some inputMode
  -            match inputMode with
  -                | Rename pos ->
  -                    model.CommandText <- model.SelectedNode.Name
  -                    this.SetCommandSelection pos model
  -                | _ ->
  -                    model.CommandText <- ""
  -
  -    member this.ExecuteCommand (model: MainModel) =
  -        match model.CommandInputMode with
  -            | Some Search -> this.Search model.CommandText false model
  -            | Some CreateFile -> this.CreateFile model
  -            | Some CreateFolder -> this.CreateFolder model
  -            | Some (Rename _) -> this.Rename model
  -            | Some Find -> () // find is executed by typing a char
  -            | None -> ()
  -        model.CommandInputMode <- None
  -
  -    member this.CommandCharTyped char (model: MainModel) =
  -        if model.CommandInputMode = Some Find then
  -            this.Find char model
  -            model.CommandInputMode <- None
  -
  -    member this.Find char (model: MainModel) =
  -        model.LastFind <- Some char
  -        model.Status <- sprintf "Find %O" char
  -        this.MoveCursorToNext (fun n -> n.Name.[0] = char) false model
  -
  -    member this.FindNext (model: MainModel) =
  -        match model.LastFind with
  -        | Some c -> this.Find c model
  -        | None -> ()
  -
  -    member this.Search searchStr reverse (model: MainModel) =
  -        model.LastSearch <- Some searchStr
  -        model.Status <- sprintf "Search \"%s\"" searchStr
  -        this.MoveCursorToNext (fun n -> Regex.IsMatch(n.Name, searchStr, RegexOptions.IgnoreCase)) reverse model
  -
  -    member this.SearchNext reverse (model: MainModel) =
  -        match model.LastSearch with
  -        | Some str -> this.Search str reverse model
  -        | None -> ()
  -
  -    member this.CreateFile (model: MainModel) =
  +    member this.CreateFile model =
           this.CreateItem fileSys.CreateFile "file" model
   
  -    member this.CreateFolder (model: MainModel) =
  +    member this.CreateFolder model =
           this.CreateItem fileSys.CreateFolder "folder" model
   
  -    member private this.CreateItem action itemType (model: MainModel) =
  +    member private this.CreateItem action itemType model =
           let name = model.CommandText
           try
               action model.Path name
  
positive.code:             model.BackStack <- []
              model.ForwardStack <- []
  
          member this.Dispatcher = function
              | CursorUp -> Sync (fun m -> this.SetCursor (m.Cursor - 1) m)
              | CursorUpHalfPage -> Sync (fun m -> this.SetCursor (m.Cursor - m.HalfPageScroll) m)
              | CursorDown -> Sync (fun m -> this.SetCursor (m.Cursor + 1) m)
              | CursorDownHalfPage -> Sync (fun m -> this.SetCursor (m.Cursor + m.HalfPageScroll) m)
              | CursorToFirst -> Sync (this.SetCursor 0)
              | CursorToLast -> Sync (fun m -> this.SetCursor (m.Nodes.Length - 1) m)
              | OpenPath p -> Sync (this.OpenPath (Path p) 0)
              | OpenSelected -> Sync this.SelectedPath
              | OpenParent -> Sync this.ParentPath
              | Back -> Sync this.Back
              | Forward -> Sync this.Forward
              | Refresh -> Sync (fun m -> this.OpenPath m.Path m.Cursor m)
              | StartInput inputMode -> Sync (this.StartInput inputMode)
              | ExecuteCommand -> Sync this.ExecuteCommand
              | CommandCharTyped c -> Sync (this.CommandCharTyped c)
              | FindNext -> Sync this.FindNext
              | SearchNext -> Sync (this.SearchNext false)
              | SearchPrevious -> Sync (this.SearchNext true)
              | TogglePathFormat -> Sync this.TogglePathFormat
              | OpenSettings -> Sync this.OpenSettings
              | OpenExplorer -> Sync this.OpenExplorer
  
      member this.SetCursor index (model: MainModel) =
          model.Cursor <- index |> max 0 |> min (model.Nodes.Length - 1)
  
      member this.MoveCursorToNext predicate reverse (model: MainModel) =
          let indexed = model.Nodes |> List.mapi (fun i n -> (i, n))
          let items =
              if reverse then
  
negative.code:             model.Status <- sprintf "Renamed %s to: %s" oldName newName
          with | ex -> model.SetExceptionStatus ex (sprintf "rename %s" oldName)
  
      member this.OpenExplorer model =
          if model.Path <> fileSys.Root then
              model.SelectedNode.Path |> fileSys.OpenExplorer
              model.Status <- "Opened Windows Explorer to: " + model.Path.Value
  
      member this.TogglePathFormat model =
          let newFormat =
              match fileSys.Format with
              | Windows -> Unix
  