anchor.diff:              | :? IntermidiateNode as cur ->
                   if List.contains current been
                   then
  -                    Others(Intermidiate(cur), false, (cur.Slot, cur.Extension))
  +                    Others(Intermidiate(cur), true, (cur.Slot, cur.Extension))
                   else
  -                    been <- List.append been [cur]
                       if cur.Others = Unchecked.defaultof<_>
                       then
  -                        let res = f cur.First true
  +                        let res = f cur.First true (List.append been [cur])
                           match res with
                           | Others(_, _, _) ->
                               res
  
positive.code:         f tree.Root
  
      let getEdgesOfMinLen (node : NonTerminalNode) =
          let rec f (curr : obj) (map : list<int * int>) (len : int) (nodes : list<obj>) =
              match curr with
                  | :? TerminalNode as node ->
                      if node.Name <> -1
                      then
                          if node.Extension <> packExtension -1 -1
                          then
                              (List.append map [(unpackExtension node.Extension)] , len + 1, List.append nodes [node] )
                          else
                              (map, len, nodes)
                      else
                          (map, len, nodes)
                  | :? PackedNode as node ->
                      let mapl, lenl, ndsl = f node.Left map len nodes
                      let mapr, lenr, ndsr = f node.Right map len nodes
                      (List.append mapl mapr, lenr + lenl, List.append (List.append ndsl ndsr) [node] )
                  | :? NonTerminalNode as node ->
                      let mp, ln, nods = f node.First map len nodes
                      let mutable min = ln
                      let mutable res = mp
                      let mutable ndes = nods
                      if node.Others <> null
                      then
                          for t in node.Others do
                              let mpn, lnn, nds = f t map len nodes
                              if lnn < min
                              then
                                  min <- lnn
                                  res <- mpn
                                  ndes <- nds
                              else do()
                      else do()
                      (res, min, List.append ndes [node])
                  | :? IntermidiateNode as node ->
                      let mp, ln, nods = f node.First map len nodes
                      let mutable min = ln
                      let mutable res = mp
                      let mutable ndes = nods
                      if node.Others <> null
                      then
                          for t in node.Others do
                              let mpn, lnn, nds = f t map len nodes
                              if lnn < min
                              then
                                  min <- lnn
                                  res <- mpn
                                  ndes <- nds
                              else do()
                      else do()
                      (res, min, List.append ndes [node])
          let edges, _, nodes = f node [] 0 []
          (edges, nodes)
  
  
negative.code:         | Intermidiate(trt) -> trt :> INode
  
      let minimiseSppf (tree : Tree<Token>) =
          let rec f (current : obj) (prevAble : bool) (been : list<obj>): ResVert =
              match current with
              | :? TerminalNode as cur ->
                  Others(Terminal(cur), true, (cur.Name, cur.Extension))
              | :? PackedNode as cur ->
                  if List.contains current been
                  then
                      Packed(cur, false)
                  else
                      let l = f cur.Left true (List.append been [cur])
                      let r = f cur.Right true (List.append been [cur])
                      match l, r with
                      | Others(vrtl, isl, extl), Others(vrtr, isr, extr) ->
                          if snd extl = packExtension -1 -1 || fst extl = -1 then
  