anchor.diff:                  | name::parameters -> generatorName := Some name; generatorParams := Some (String.concat " " parameters)
                   | _ -> failwith "You need to specify generator name"
               ), "Generator name. Use -ag to list available."
  -         "-ag", ArgType.Unit (printItems "generators" AddinGeneratorNames !generatorName), "Available generators"
  +         "-ag", ArgType.Unit (printItems "generators" addinGeneratorNames !generatorName), "Available generators"
            "-c", ArgType.String (fun s -> conversions.Add s), "Conversion applied in order. Use -ac to list available."
  -         "-ac", ArgType.Unit (printItems "conversions" AddinConversionNames None), "Available conversions"
  +         "-ac", ArgType.Unit (printItems "conversions" addinConversionNames None), "Available conversions"
            "-D", ArgType.String (fun s -> userDefs := !userDefs @ [s]), "User defined constants for YardFrontend lexer."
            "-U", ArgType.String (fun s -> userDefs := List.filter ((<>) s) !userDefs), 
                   "Remove previously defined constants for YardFrontend lexer."
  
positive.code:     AddinManager.Initialize()
      AddinManager.Registry.Update(null)
  
      let AddinFrontend = AddinManager.GetExtensionObjects (typeof<Frontend>) |> Seq.cast<Frontend>
      let AddinConversion = AddinManager.GetExtensionObjects (typeof<Conversion>) |> Seq.cast<Conversion>
      let AddinGenerator = AddinManager.GetExtensionObjects (typeof<Generator>) |> Seq.cast<Generator>
      let AddinFrontendNames = Seq.map (fun (elem : Frontend) -> elem.Name) AddinFrontend
      let AddinConversionNames = Seq.map (fun (elem : Conversion) -> elem.Name) AddinConversion
      let AddinGeneratorNames = Seq.map (fun (elem : Generator) -> elem.Name) AddinGenerator
  
      let userDefs = ref []
      let userDefsStr = ref ""
  
      feName := // Fill by default value
          if Seq.exists (fun (elem : Frontend) -> elem.Name = "YardFrontend") AddinFrontend
          then Some "YardFrontend"
          else
              let tmpName = (Seq.head AddinFrontend).Name
              Some tmpName
              
      generatorName :=
          if Seq.exists (fun (elem : Generator) -> elem.Name = "RNGLRGenerator") AddinGenerator
          then Some "RNGLRGenerator"
          else 
              let tmpName = (Seq.head AddinGenerator).Name
              Some tmpName
  
      let generateSomething = ref true
  
  
negative.code:                 else
                      {ilTree
                       with grammar =
                              match Seq.tryFind (fun (elem : Conversion) -> elem.Name = parameters.[0]) addinConversions with 
                              | Some conv -> conv.ConvertGrammar (ilTree.grammar, parameters.[1..parameters.Length - 1])
                              | None -> failwith <| "Conversion not found: " + parameters.[0]
                              }
  