anchor.diff:  open System.Collections.Generic
   open Yard.Generators.Common.DataStructures
   
  +[<Measure>] type key
  +[<Measure>] type extension
  +
   /// Arguments for tanslation calling, seen by user
   type TranslateArguments<'Token, 'Position> = {
       tokenToRange : 'Token -> 'Position * 'Position
  
positive.code:         | :? int as x when x < 0 -> Unchecked.defaultof<_>, true
          | _ -> failwith "Strange tree - singleNode with non-negative value"
  
      member this.Root = root
      member this.RulesCount = rules.GetLength(0)
  
    
  
      member this.AstToDot (indToString : int -> string) tokenToNumber (leftSide : array<int>) (path : string) =
          
          let nodeToNumber = new System.Collections.Hashtable({new Collections.IEqualityComparer with
                                                                      override this.Equals (x1, x2) = Object.ReferenceEquals (x1, x2)
                                                                      override this.GetHashCode x = x.GetHashCode()})
          use out = new System.IO.StreamWriter (path : string)
          out.WriteLine("digraph AST {")
          let createNode num isAmbiguous nodeType (str : string) =
              let label =
                  let cur = str.Replace("\n", "\\n").Replace ("\r", "")
  
negative.code: //let inline private setPos p (x : AST) = match x with NonTerm n -> n.pos <- p | SingleNode _ -> failwith "Attempt to get num of single node"
  
  let private emptyArr = [||]
  type private DotNodeType = FamilyNode | AstNode | Intermidiate | Terminal
  
  let inline packExtension left right : int64<extension> =  LanguagePrimitives.Int64WithMeasure ((int64 left <<< 32) ||| int64 right)
  let inline getRightExtension (long : int64<extension>) = int <| ((int64 long) &&& 0xffffffffL)
  let inline getLeftExtension (long : int64<extension>)  = int <| ((int64 long) >>> 32)
  
  
  let inline packLabel rule position = (int rule <<< 16) ||| int position
  let inline getRule packedValue = int packedValue >>> 16
  let inline getPosition (packedValue : int) = int (packedValue &&& 0xffff)
  
  let inline pack3ToInt64 p l r : int64<key>        = LanguagePrimitives.Int64WithMeasure (((int64 p) <<< 52) ||| ((int64 l) <<< 26) ||| (int64 r))
  let inline getProduction (long : int64<key>)      = int (int64 long >>> 52)
  let inline getLeftExtension3 (long : int64<key>)  = int((int64 long <<< 12) >>> 38)
  let inline getRightExtension3 (long : int64<key>) = int((int64 long <<< 38) >>> 38)
  
  [<AllowNullLiteral>]
  type Tree<'TokenType> (tokens : array<'TokenType>, root : obj, rules : int[][]) =
  