anchor.diff:  %% @doc Get the process arguments of the given optimized map inner dict.
   %%
   
  --spec unpack_opt_inner_dict(dict:dict(lasp_vertex(),
  -                                      {lasp_vertex(),
  -                                       #process_metadata{}})) -> list(process_args()).
  -unpack_opt_inner_dict(OptInnerMap) ->
  -    dict:fold(fun(Parent, {Child, Metadata}, Acc) ->
  -        ReadFun = Metadata#process_metadata.read,
  -        Read = {Parent, ReadFun},
  -
  -        Transform = Metadata#process_metadata.transform,
  -
  -        WriteFun = Metadata#process_metadata.write,
  -        Write = {Child, WriteFun},
  -
  -        ProcessArgs = {[Read], Transform, Write},
  -        [ProcessArgs | Acc]
  -    end, [], OptInnerMap).
  +-spec unpack_optimized_map(contract_path(), list(#process_metadata{})) -> list(process_args()).
  +unpack_optimized_map(VSeq, MetadataList) ->
  +    mapi(fun(Pos, El) ->
  +        ReadFun = El#process_metadata.read,
  +        Read = {lists:nth(Pos, VSeq), ReadFun},
  +
  +        Transform = El#process_metadata.transform,
  +
  +        WriteFun = El#process_metadata.write,
  +        Write = {lists:nth(Pos + 1, VSeq), WriteFun},
  +
  +        {[Read], Transform, Write}
  +    end, MetadataList).
  +
   
   %% @doc Given a path contraction candidate in the graph, return the process
   %%      metadata from all intermediate edges.
   %%
   %%      Used to build the optimized map.
   %%
  --spec get_metadata(digraph:graph(),
  -                   contract_path()) -> list({lasp_vertex(),
  -                                             {lasp_vertex(), #process_metadata{}}}).
  +-spec get_metadata(digraph:graph(), contract_path()) -> list(#process_metadata{}).
   
   get_metadata(G, [_ | Tail]=VSeq) ->
       zipwith(fun(Src, Dst) ->
  -        {Src, {Dst, lists:nth(1, get_metadata(G, Src, Dst))}}
  +        lists:nth(1, get_metadata(G, Src, Dst))
       end, VSeq, Tail).
   
   %% @doc Get the process metadata for all edges between the given vertices.
  
positive.code: cleave_associated_path(G, Pid, OptMap) ->
      case dict:find(Pid, OptMap) of
          error -> ok;
          {ok, {VSeq, InnerDict}} ->
              ProcessArgs = unpack_opt_inner_dict(InnerDict),
              tag_vertices(G, VSeq, []),
              spawn_link(fun() ->
                  lists:foreach(fun({_Reads, _TransForms, _Write}=Args) ->
                      lasp_process:start_dag_link(tuple_to_list(Args))
  
negative.code:         end, OldPids)
      end),
  
      dict:store(Pid, {VSeq, Metadata}, OptMap).
  
  %% @doc If the given vertex was part of a contracted path, cleave it
  %%
  