anchor.diff:              let rec GetInputs(f: Address) : Set<Address> =
                   // if f is a formula then get the addresses
                   // of its inputs
  -                if formula_inputs.ContainsKey(f) then
  +                if formula_inputs.ContainsKey f then
                       Set.map (fun input ->
                           GetInputs(input)
                       ) (formula_inputs.[f]) |> Set.unionMany
                   // if f is not a formula then it IS an input
                   else
                       set [f]
  -            GetInputs(formula_address)
  +            GetInputs formula_address
   
           // this returns all output formulas that depend on a particular input
           // note that this computes the transitive closure of the "is output for" relation
  
positive.code:             | Some(addrs) -> addrs
              | None -> Set.empty
  
          // this returns only the ranges that are referenced directly in this formula
          // note: used for classic DataDebug algorithm
          member self.GetInputRanges(expr: Expression) : Set<Range> =
              SpreadsheetUtility.GetRangesFromExpr(expr)
negative.code:     open System.Collections.Generic
      open SpreadsheetAST
      type DirectedAcyclicGraph(formulas: Dictionary<Address,Expression>, data: Dictionary<Address,string>) =
          // convert inputs into immutable maps, for thread-safety
          let fs = Seq.map (fun (pair: KeyValuePair<Address,Expression>) -> (pair.Key, pair.Value)) formulas |> Map.ofSeq
          let ds = Seq.map (fun (pair: KeyValuePair<Address,string>) -> (pair.Key, pair.Value)) data |> Map.ofSeq
  
          let formula_addresses = Map.toSeq fs |> Seq.map (fun (addr,_) -> addr) |> Set.ofSeq
  
          // these are all of the input addresses for a formula output
          // note that some inputs are data and others are formulas
          let formula_inputs =
              Map.map (fun addr expr ->
                  let ranges = SpreadsheetUtility.GetRangesFromExpr(expr)
                  let addrs = SpreadsheetUtility.GetAddressesFromExpr(expr)
                  let raddrs = Set.unionMany (Set.map (fun (r: Range) -> r.GetAddresses()) ranges)
                  Set.union addrs raddrs
              ) fs
  
          // these are all of the outputs that depend on a particular input
          let cell_outputs =
              Map.map (fun iaddr _ ->
                  Set.filter (fun faddr ->
                      formula_inputs.[faddr].Contains iaddr
                  ) formula_addresses
              ) ds
  
          // this returns addresses of all cells that provide input *data* for a formula
          // note that this computes the transitive closure of the "is input to" relation
  