anchor.diff:  
   let getPeerInfo vs =
       let inline setLocs x = 
  -        Set.ofSeq (Seq.map (fun (v: Topology.State) -> v.Loc) x) 
  +        Set.ofSeq (Seq.map (fun (v: Topology.State) -> Router v.Loc) x) 
       let all = vs |> setLocs
       let allIn = vs |> Seq.filter Topology.isInside |> setLocs
       let allOut = vs |> Seq.filter Topology.isOutside |> setLocs
  
positive.code:     let toInside, toOutside = 
          List.ofSeq outgoing 
          |> List.partition (fun v -> Topology.isInside v.Node)
      let insideExport = [("in", [SetComm (string x.State)])]
      let specialCase = ref false
      let exports = List.ofSeq toOutside |> List.map (fun v -> (v.Node.Loc, getExport specialCase inExports x v)) 
      if not !specialCase then
          let sendToLocs = Seq.map (fun v -> v.Node.Loc) outgoing |> Set.ofSeq
          let sendToLocs = 
              match unqMatchPeer with
              | Some x -> Set.add x sendToLocs
              | None -> sendToLocs
          if sendToLocs.IsSupersetOf outPeers then
              [("*", [SetComm(string x.State)])]
          else exports @ insideExport
      else  exports @ insideExport
  
  
negative.code:     let peermatches, regexes = List.partition Outgoing.isPeerMatch (List.ofSeq outgoingMatches)
      // get peer topology location information
      let mutable peers = Set.ofList (List.map Outgoing.getPeerMatch peermatches)
      let peerLocs = Set.map (fun v -> Router (CGraph.loc v)) peers
      let peersIn = Set.filter (fun v -> Topology.isInside v.Node) peers
      let peersOut = Set.filter (fun v -> Topology.isOutside v.Node) peers
      let peerLocsIn =  Set.map (fun v -> Router (CGraph.loc v)) peersIn
      let peerLocsOut = Set.map (fun v -> Router (CGraph.loc v)) peersOut
      // get peer state product graph information
      let mutable matches = List.map (fun r -> Match.PathRE (Outgoing.getRegexMatch r)) regexes
      let states = peers |> Set.map (fun v -> v.State)
      let statesIn = peers |> Set.filter (fun v -> Topology.isInside v.Node) |> Set.map (fun v -> v.State)
      let statesOut = peers |> Set.filter (fun v -> Topology.isOutside v.Node) |> Set.map (fun v -> v.State)
      if peerLocs = allPeers && (eqStates states) then 
          matches <- Match.State(string (Set.minElement states), Any) :: matches
          peers <- Set.empty
      else 
          if peerLocsIn = inPeers && (eqStates statesIn) && not peerLocsIn.IsEmpty then 
              matches <- Match.State(string (Set.minElement statesIn), In) :: matches
              peers <- Set.difference peers peersIn
          if peerLocsOut = outPeers && (eqStates statesOut) && not peerLocsOut.IsEmpty then 
              matches <- Match.Peer(Out) :: matches
              peers <- Set.difference peers peersOut
          for v in peers do
              let m = 
                  if Topology.isInside v.Node then  
                      Match.State(string v.State, Router v.Node.Loc)
                  else Match.Peer(Router v.Node.Loc)
              matches <- m :: matches
      matches
  
  