def METHOD_NAME(self, graph: sd.SDFGState, sdfg: sd.SDFG):
    map_entry = self.map_entry
    node1 = self.node1
    node2 = self.node2
    # Steps:
    # 1. Find unique subsets
    # 2. Find sets of contiguous subsets
    # 3. Create transients for subsets
    # 4. Redirect edges through new transients
    edges1 = set(e.src_conn for e in graph.edges_between(map_entry, node1))
    edges2 = set(e.src_conn for e in graph.edges_between(map_entry, node2))
    # Only apply to first connector (determinism)
    conn = sorted(edges1 & edges2)[0]
    edges = [e for e in graph.out_edges(map_entry) if e.src_conn == conn]
    # Get original data descriptor
    dname = edges[0].data.data
    desc = sdfg.arrays[edges[0].data.data]
    # Get unique subsets
    unique_subsets = set(e.data.subset for e in edges)
    # Find largest contiguous subsets
    try:
        # Start from stride-1 dimension
        contiguous_subsets = helpers.find_contiguous_subsets(unique_subsets,
                                                             dim=next(i for i, s in enumerate(desc.strides)
                                                                      if s == 1))
    except (StopIteration, NotImplementedError):
        warnings.warn("DeduplicateAcces::Not operating on Stride One Dimension!")
        contiguous_subsets = unique_subsets
    # Then find subsets for rest of the dimensions
    contiguous_subsets = helpers.find_contiguous_subsets(contiguous_subsets)
    # Map original edges to subsets
    edge_mapping = defaultdict(list)
    for e in edges:
        for ind, subset in enumerate(contiguous_subsets):
            if subset.covers(e.data.subset):
                edge_mapping[ind].append(e)
                break
        else:
            raise ValueError("Failed to find contiguous subset for edge %s" % e.data)
    # Create transients for subsets and redirect edges
    for ind, subset in enumerate(contiguous_subsets):
        name, _ = sdfg.add_temp_transient(subset.size(), desc.dtype)
        anode = graph.add_access(name)
        graph.add_edge(map_entry, conn, anode, None, Memlet(data=dname, subset=subset))
        for e in edge_mapping[ind]:
            graph.remove_edge(e)
            new_memlet = copy.deepcopy(e.data)
            new_edge = graph.add_edge(anode, None, e.dst, e.dst_conn, new_memlet)
            for pe in graph.memlet_tree(new_edge):
                # Rename data on memlet
                pe.data.data = name
                # Offset memlets to match new transient
                pe.data.subset.offset(subset, True)