anchor.diff:          Receive = None
           Originate = None
           Prefs = None
  -        Fail = Some FRCantControlPeers }
  +        Fail = Some FRInconsistentPrefs }
         { Name = "Backbone"
           Explanation = "Incoming traffic from multiple peers"
           Topo = tBackboneWAN
  
positive.code:                 | None -> ()
                  | Some v -> raise (UncontrollablePeerPreferenceException p1.Node.Loc)
              // preferences for different peers must be implementable from internal preferences
              // TODO: use inferred preferences rather than exact
              if not (bestCasePrefs.[p1] > worstCasePrefs.[p2]) then 
                if p1.Node.Loc <> p2.Node.Loc then 
                  raise (UncontrollablePeerPreferenceException p1.Node.Loc)
          let mutable actions = []
  
negative.code:       |> Seq.map (fun (x, y) -> (x, Seq.map snd y))
        |> Seq.sortBy fst
      
      // Collect inferred preferences as map
      let prefMap = Dictionary()
      for kv in ord do
        let mutable j = 0
        for x in kv.Value do
          j <- j + 1
          prefMap.[x] <- j
      // Collect worst case pref for each peer
      let mutable worstCasePrefs = Map.empty
      let mutable bestCasePrefs = Map.empty
      let mutable inferredWorstPrefs = Map.empty
      let mutable inferredBestPrefs = Map.empty
      let f1 = (fun v -> v.Accept)
      let f2 = (fun v -> prefMap.[v])
      for p in info.Peers do
        worstCasePrefs <- Map.add p (getMostPreference Seq.max f1 cg p) worstCasePrefs
        bestCasePrefs <- Map.add p (getMostPreference Seq.min f1 cg p) bestCasePrefs
        inferredWorstPrefs <- Map.add p (getMostPreference Seq.max f2 cg p) inferredWorstPrefs
        inferredBestPrefs <- Map.add p (getMostPreference Seq.min f2 cg p) inferredBestPrefs
      // Run through each preference level and check for safe preference
      let exportMap = ref Map.empty
      let mutable i = 0
  