anchor.diff:  flow_rules([{Port1, of_port, _}, port_of, {_Switch, of_switch, SwitchMetadata},
   	    port_of | [{Port2, of_port, _} | _] = Tail], Graph) ->
       %% Add bidirectional flow rules.
  -    SwitchId = maps:get(datapath_id, SwitchMetadata),
  +    SwitchId = binary_to_list(maps:get(<<"datapath_id">>, SwitchMetadata)),
       Rule1 = {
         [{in_port, fc_utils:id_to_port_no(Port1)}],
         [{apply_actions, [{output, fc_utils:id_to_port_no(Port2), no_buffer}]}],
  
positive.code: -module(fc_find_path).
  
  -export([path_flow_rules/3]).
  
  path_flow_rules(Ep1, Ep2, Graph) ->
      VerticesEdges = vertices_edges_path(Graph, Ep1, Ep2),
      FlowRules = flow_rules(VerticesEdges, Graph),
      [{DpId, lists:append([TheFlowRules || {TheDpId, TheFlowRules} <- FlowRules,
  
negative.code:     vertices_edges(Path, Graph).
  
  vertices_edges([Id], Graph) ->
      {Id, #{<<"type">> := Type} = Metadata} = digraph:vertex(Graph, Id),
      [{Id, binary_to_atom(Type, utf8), Metadata}];
  vertices_edges([Id1, Id2 | _] = [Id1 | Tail], Graph) ->
      {Id1, #{<<"type">> := Type1} = Metadata1} = digraph:vertex(Graph, Id1),
      {Id2, #{}} = digraph:vertex(Graph, Id2),
      %% TODO: is there a nicer way to get the edge between Id1 and Id2?
      [Edge] = edges_between(Id1, Id2, Graph),
      {Edge, Id1, Id2, #{<<"type">> := EdgeType}} = digraph:edge(Graph, Edge),
      [{Id1, binary_to_atom(Type1, utf8), Metadata1}, binary_to_atom(EdgeType, utf8)]
  	++ vertices_edges(Tail, Graph).
  
  flow_rules([{_, endpoint, _}], _Graph) ->
  