anchor.diff:        |> 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 cg p) worstCasePrefs
  -      bestCasePrefs <- Map.add p (getMostPreference Seq.min cg p) bestCasePrefs
  +      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
  
positive.code:       let msg = sprintf "Unused preference %d policy " i + sprintf "for predicate %s" predStr
        warning msg) unusedPrefs
    try 
      // check that BGP can ensure incoming traffic compliance
      let inExports = Incoming.configureIncomingTraffic cg
      // check aggregation failure consistency
      let k = getMinAggregateFailures cg pred aggInfo
      // check that there is a valid ordering for BGP preferences to ensure compliance
      let (ordering, orderTime) = Profile.time (Consistency.findOrderingConservative idx) cg
      match ordering with
      | Ok ord -> 
        let config, configTime = Profile.time (genConfig cg pred ord) inExports
        
        let result = 
  
negative.code:   
    let getUnique peers = Set.ofSeq (Seq.map (fun p -> p.Node.Loc) peers)
    
    let getMostPreference f g (cg : CGraph.T) (x : CgState) = 
      x
      |> CGraph.neighborsIn cg
      |> Seq.filter CGraph.isInside
      |> Seq.map g
      |> f
    
    let getSeen cg (peers : seq<CgState>) = 
  