anchor.diff:                      match e1.rule, e2.rule with 
                       | PRef (name1, _), PRef (name2, _) ->
                           let nonterm1 = NonTerminal <| Source.toString name1
  +                        if not <| nonterminals.Contains nonterm1
  +                        then
  +                            nonterminals.Add nonterm1
                           let nonterm2 = NonTerminal <| Source.toString name2
  +                        if not <| nonterminals.Contains nonterm2
  +                        then
  +                            nonterminals.Add nonterm2
                           if not <| crl.ContainsKey (nonterm1, nonterm2)
                           then
                               crl.Add((nonterm1, nonterm2), new ResizeArray<NonTerminal*Probability.T>())
  
positive.code:         (parsingMatrix.[S], multCount)
  
  
      let recognize (graph:Graph.T)
                    squareMatrix
                    (loadIL:t<Source.t, Source.t>)
                    nonterminals
                    S =
          let grammar = loadIL.grammar
          
          let crl = new Dictionary<NonTerminal * NonTerminal, ResizeArray<NonTerminal*Probability.T>>()
          let srl = new Dictionary<char, ResizeArray<NonTerminal*Probability.T>>()
          let crl_result = new Dictionary<NonTerminal * NonTerminal, (NonTerminal * Probability.T) list>()
  
negative.code: 
          for module' in grammar do
              for r in module'.rules do
                  let nonterm = NonTerminal <| Source.toString r.name
                  if not <| nonterminals.Contains nonterm
                  then
                      nonterminals.Add nonterm
                      if r.isStart
                      then
                          S := nonterm
  
                  match r.body with
                  | PSeq([elem],_,_) ->
                      match elem.rule with
  