anchor.diff:      }
       let allTokens = seq []
       let res =
  -        let g = loadDotToQG "s4.dot"
  +        let g = loadDotToQG path
           (new Yard.Generators.RNGLR.AbstractParser.Parser<_>()).Parse buildAstAbstract g
  -        //buildAstAbstract 
  -    //buildAst allTokens
  -    //printfn "Time for parse file %s = %A" path (System.DateTime.Now - start)
       res
   
   let p = new ProjInfo()
   let mutable counter = 1<id>
  +let resultDirectoryPath = ref @"../../result\"
  +
  +let getResultFileName (path : string) pref  = 
  +    !resultDirectoryPath + pref + path.Substring(path.LastIndexOf("\\") + 1)
   
   let Parse (srcFilePath:string) = 
       let StreamElement = new StreamReader(srcFilePath, System.Text.Encoding.UTF8)  
       let map = p.GetMap StreamElement
  -    //Array.iter (printfn "%A") map
  -    //Lexer.id <- counter
       p.AddLine counter map
       counter <- counter + 1<id>
  -    //Lexer.id <- from (ProjInfo)
       match justParse srcFilePath with
       | Yard.Generators.RNGLR.Parser.Error (num, tok, msg, dbg) ->
  -        //let coordinates = 
  -//            let x,y = tokenPos tok
  -//            let x = p.GetCoordinates x
  -//            let y = p.GetCoordinates y
  -//            sprintf "(%A,%A) - (%A,%A)" x.Line x.Column y.Line y.Column
           let data =
               let d = tokenData tok
               if isLiteral tok then ""
               else (d :?> SourceText).text
           let name = tok |> tokenToNumber |> numToString
           printfn "Error in file %s on position  on Token %s %s: %s" srcFilePath name data msg
  -        //dbg.lastTokens(10) |> printfn "%A"
  -        dbg.drawGSSDot @"..\..\stack.dot"
  +        dbg.drawGSSDot (getResultFileName srcFilePath "stack_")
       | Yard.Generators.RNGLR.Parser.Success ast ->
           let GC_Collect () = 
               GC.Collect()    
  
positive.code: let path name = System.IO.Path.Combine(baseInputGraphsPath,name)
  
  let loadDotToQG gFile =
      let g = loadGraphFromDOT(path gFile)
      let qGraph = ParserInputGraph()
          //new AdjacencyGraph<int, TaggedEdge<_,_>>()
      let getTkn str =
          try
              Yard.Examples.MSParser.genLiteral str 0UL 0UL
  
negative.code:         |> Seq.iter (fun (prods, gv) -> 
              printfn "conf# %i  prods: %A" (Seq.length gv) prods
              gv |> (fun s -> if Seq.length s > 5 then Seq.take 5 s else s) |> Seq.map fst |> Seq.iter (printfn "    %A"))
          defaultAstToDot ast (getResultFileName srcFilePath "ast_")
         
  let CreateEmptyResultDirectory = 
      if (System.IO.Directory.Exists(!resultDirectoryPath))
      then System.IO.Directory.Delete(!resultDirectoryPath, true)
      System.IO.Directory.CreateDirectory(!resultDirectoryPath)
          
  let ParseAllDirectory (directoryName:string) =
      resultDirectoryPath := directoryName + @"\results\"
      CreateEmptyResultDirectory |> ignore
      System.IO.Directory.GetFiles(directoryName,"*.dot")
      |> Array.iter Parse
  
  do 
      let inPath = ref @"..\..\tests\s2.dot"
      let parseDir = ref false
      let commandLineSpecs =
          ["-f", ArgType.String (fun s -> inPath := path s), "Input file."
           "-d", ArgType.String (fun s -> parseDir := true; inPath := s), "Input dir. Use for parse all files in specified directory."
           ] |> List.map (fun (shortcut, argtype, description) -> ArgInfo(shortcut, argtype, description))
      ArgParser.Parse commandLineSpecs
  