anchor.diff:                                      f nodes.other.[i]
                                   needDo <- needDo || nodes.other.[i] = nd
   
  -            /// applies function to nodes which are located to the left than node nd. 
  +            /// <summary>
  +            /// applies function f to nodes which are located to the left than node nd. 
               /// Left sibling of nd is first.
  +            /// </summary>
  +            /// <param name="nd"></param>
  +            /// <param name="f"></param>
               member nodes.doForAllBeforeNode nd f = 
                   if nodes.fst <> null && nodes.fst <> nd
                   then 
  
positive.code:             | _ -> failwith ""
          printAst 0 root
  
      member this.AstToDot (indToString : int -> string) tokenToNumber (leftSide : array<int>) (path : string) =
          let next =
              let cur = ref order.Length
  
negative.code: 
              and processAST (ast : OtherAST) = 
                  let value = !count
                  let oldNd = !nd
                  processFamily ast.first
                  
                  if ast.other <> null
                  then 
                      Array.iter (fun fam -> 
                          count := value
                          nd := oldNd
                          processFamily fam) ast.other
  
              match current with
              | :? OtherFamily as fam -> processFamily fam
              | :? OtherAST as ast -> processAST ast
              | _ -> failwith ""
  
              while !count <> 0 do
                  let father = 
                      match current with
                      | :? OtherAST as ast -> 
                          nd := box current
                          if ast.parent.other.Length > 0 
                          then
                              ast.parent.other
                              |> Array.iter (fun parent -> contexts.Push <| new Context (parent :?> OtherFamily, !nd, !count))
                          
                          ast.parent.first
                      | :? OtherFamily as fam -> fam.parent
                      | _ -> failwithf "Unexpected error."
                  
                  match father with
                  | :? OtherAST as ast -> processAST ast
                  | :? OtherFamily as fam -> processFamily fam
                  | _ -> failwithf "Unexpected error. Father node doesn't be null"
                  
                  current <- father
          res
  
      ///
      /// <summary>
      /// Prints ast in console
      /// </summary>
      member this.PrintAst() =            
          let rec printAst ind ast =
              let printInd num (x : 'a) =
  