def METHOD_NAME(self, graph: dace.SDFGState, sdfg: dace.SDFG):
    # Extract the map and its entry and exit nodes.
    map_entry = self.map_entry
    map_exit = graph.exit_node(map_entry)
    current_map = map_entry.map
    # Create new maps
    new_maps = [
        nodes.Map(current_map.label + '_' + str(param), [param],
                  subsets.Range([param_range]),
                  schedule=dtypes.ScheduleType.Sequential)
        for param, param_range in zip(current_map.params[1:], current_map.range[1:])
    ]
    current_map.params = [current_map.params[0]]
    current_map.range = subsets.Range([current_map.range[0]])
    # Create new map entries and exits
    entries = [nodes.MapEntry(new_map) for new_map in new_maps]
    exits = [nodes.MapExit(new_map) for new_map in new_maps]
    # Create edges, abiding by the following rules:
    # 1. If there are no edges coming from the outside, use empty memlets
    # 2. Edges with IN_* connectors replicate along the maps
    # 3. Edges for dynamic map ranges replicate until reaching range(s)
    for edge in graph.out_edges(map_entry):
        graph.remove_edge(edge)
        graph.add_memlet_path(map_entry,
                              *entries,
                              edge.dst,
                              src_conn=edge.src_conn,
                              memlet=edge.data,
                              dst_conn=edge.dst_conn)
    # Modify dynamic map ranges
    dynamic_edges = dace.sdfg.dynamic_map_inputs(graph, map_entry)
    for edge in dynamic_edges:
        # Remove old edge and connector
        graph.remove_edge(edge)
        edge.dst.remove_in_connector(edge.dst_conn)
        # Propagate to each range it belongs to
        path = []
        for mapnode in [map_entry] + entries:
            path.append(mapnode)
            if any(edge.dst_conn in map(str, symbolic.symlist(r)) for r in mapnode.map.range):
                graph.add_memlet_path(edge.src,
                                      *path,
                                      memlet=edge.data,
                                      src_conn=edge.src_conn,
                                      dst_conn=edge.dst_conn)
    # Create new map exits
    for edge in graph.in_edges(map_exit):
        graph.remove_edge(edge)
        graph.add_memlet_path(edge.src,
                              *exits[::-1],
                              map_exit,
                              memlet=edge.data,
                              src_conn=edge.src_conn,
                              dst_conn=edge.dst_conn)
    from dace.sdfg.scope import ScopeTree
    scope = None
    queue: List[ScopeTree] = graph.scope_leaves()
    while len(queue) > 0:
        tnode = queue.pop()
        if tnode.entry == entries[-1]:
            scope = tnode
            break
        elif tnode.parent is not None:
            queue.append(tnode.parent)
    else:
        raise ValueError('Cannot find scope in state')
    consolidate_edges(sdfg, scope)
    return [map_entry] + entries