anchor.diff:      |> Seq.toList
       |> buildPaths [baseDir]
       |> List.map normalizeOutputPath
  -    |> List.map (fun x->trace(x) ;x) 
   
   /// Internal representation of a file set.
   type FileIncludes =
  
positive.code:         buildPaths subDirs t
      | Recursive :: [] ->
          let dirs = 
              Seq.collect (fun dir ->        tracefn "All subdirs and files %s" dir; Directory.EnumerateFileSystemEntries(dir, "*", SearchOption.AllDirectories)) acc
              |> Seq.toList
          buildPaths (acc @ dirs) []
      | Recursive :: t ->
          
          let dirs = 
              Seq.collect (fun dir ->       tracefn "All subdirs %s" dir; Directory.EnumerateDirectories(dir, "*", SearchOption.AllDirectories)) acc
              |> Seq.toList
          buildPaths (acc @ dirs) t
      | FilePattern(pattern) :: t ->
          tracefn "pattern %A"  acc
          Seq.collect (fun dir -> tracefn "All files %s in %s" pattern dir; Directory.EnumerateFiles(dir, pattern)) acc
          |> Seq.toList
           
  let private isDrive =
  
negative.code:         Directory.EnumerateDirectories(root, dir, SearchOption.TopDirectoryOnly) |> Seq.toList
      else
          let path= root + directorySeparator + dir + directorySeparator
          let di = 
              if absolute then new DirectoryInfo(dir) else 
              new DirectoryInfo(path)
          if di.Exists then [di.FullName] else []
          
  let rec private buildPaths acc (input : SearchOption list) =
      match input with
      | [] -> acc
      | Directory(name) :: t -> 
          let subDirs = 
              acc
              |> List.map (checkSubDirs false name) 
              |> List.concat
          buildPaths subDirs t
      | Drive(name) :: t ->
          let subDirs = 
  