anchor.diff:              let u = stack.Pop()
               if u < 0 then
                   res.Add <| -u-1
  -            else
  +            elif not reachable.[u] then
                   stack.Push <| -u-1
                   reachable.[u] <- true
                   match nodes.[u] with
                   | NonTerm list ->
  -                    !list |> List.iter iterChildren
  +                    !list |> List.iter (
  +                        fun (_,children) ->
  +                            for j in children do
  +                                if not reachable.[j] then
  +                                    stack.Push j)
                   | _ -> ()
               
           let ret = res.ToArray()
  
positive.code:             | _ -> ()
                  
      member this.ChooseSingleAst () = 
          this.EliminateCycles()
          for x in order do
              if reachable.[x] then
                  match nodes.[x] with
                  | NonTerm list ->
                      match !list with
                      | h::_::_ -> list := [h]
                      | _ -> ()
                  | _ -> ()
          for x in order do
              reachable.[x] <- false
  
negative.code:                 match nodes.[x] with
                  | Term t -> result.[x] <- box t
                  | Epsilon eps ->
                      result.[x] <- epsilons.[eps].Translate funs leftSides concat [||]//epsilons
                  | NonTerm list ->
                      let res = 
                          !list
  