code: def multi_rmat(
      n_edgelists,
      min_scale,
      max_scale,
      edge_factor,
      size_distribution,
      edge_distribution,
      seed=42,
      clip_and_flip=False,
      scramble_vertex_ids=False,
      include_edge_weights=False,
      minimum_weight=None,
      maximum_weight=None,
      dtype=None,
      include_edge_ids=False,
      include_edge_types=False,
      min_edge_type_value=None,
      max_edge_type_value=None,
      mg=False,
  ):
      """
      Generate multiple Graph objects using a Recursive MATrix (R-MAT) graph
      generation algorithm.
  
      Parameters
      ----------
      n_edgelists : int
          Number of edge lists (graphs) to generate.
  
      min_scale : int
          Scale factor to set the minimum number of vertices in the graph.
  
      max_scale : int
          Scale factor to set the maximum number of vertices in the graph.
  
      edge_factor : int
          Average number of edges per vertex to generate
  
      size_distribution : int
          Distribution of the graph sizes, impacts the scale parameter of the
          R-MAT generator.
          '0' for POWER_LAW distribution and '1' for UNIFORM distribution.
  
      edge_distribution : int
          Edges distribution for each graph, impacts how R-MAT parameters
          a,b,c,d, are set.
          '0' for POWER_LAW distribution and '1' for UNIFORM distribution.
  
      seed : int
          Seed value for the random number generator.
  
      clip_and_flip : bool, optional (default=False)
          Flag controlling whether to generate edges only in the lower triangular
          part (including the diagonal) of the graph adjacency matrix
          (if set to True) or not (if set to False).
  
      scramble_vertex_ids : bool
          Flag controlling whether to scramble vertex ID bits (if set to True)
          or not (if set to False); scrambling vertx ID bits breaks correlation
          between vertex ID values and vertex degrees.
  
      include_edge_weights : bool, optional (default=False)
          Flag controlling whether to generate edges with weights
          (if set to True) or not (if set to ').
  
      minimum_weight : float
          Minimum weight value to generate if 'include_edge_weights' is True
          otherwise, this parameter is ignored.
  
      maximum_weight : float
          Maximum weight value to generate if 'include_edge_weights' is True
          otherwise, this parameter is ignored.
  
      include_edge_ids : bool, optional (default=False)
          Flag controlling whether to generate edges with ids
          (if set to True) or not (if set to False).
  
      include_edge_types : bool, optional (default=False)
          Flag controlling whether to generate edges with types
          (if set to True) or not (if set to False).
  
      min_edge_type_value : int
          Minimum edge type to generate if 'include_edge_types' is True
          otherwise, this parameter is ignored.
  
      max_edge_type_value : int
          Maximum edge type to generate if 'include_edge_types' is True
          otherwise, this paramter is ignored.
  
      dtype : numpy.float32, numpy.float64, cupy.float32, cupy.float64,
      "float32", "float64"
          The type of weight to generate which is ignored unless
          include_weights is true.
  
      mg : bool, optional (default=False)
          If True, R-MATs generation occurs across multiple GPUs. If False, only a
          single GPU is used.  Default is False (single-GPU)
          # FIXME: multi GPU RMATs generation not supported yet.
  
      Returns
      -------
      list of cugraph.Graph instances
      """
      _ensure_args_rmat(
          n_edgelists=n_edgelists,
          min_scale=min_scale,
          max_scale=max_scale,
          edge_factor=edge_factor,
          size_distribution=size_distribution,
          edge_distribution=edge_distribution,
          seed=seed,
          include_edge_weights=include_edge_weights,
          minimum_weight=minimum_weight,
          maximum_weight=maximum_weight,
          dtype=dtype,
          include_edge_ids=include_edge_ids,
          include_edge_types=include_edge_types,
          min_edge_type_value=min_edge_type_value,
          max_edge_type_value=max_edge_type_value,
          multi_rmat=True,
          clip_and_flip=clip_and_flip,
          scramble_vertex_ids=scramble_vertex_ids,
      )
  
      edgelists = pylibcugraph_generate_rmat_edgelists(
          ResourceHandle(),
          seed,
          n_edgelists,
          min_scale,
          max_scale,
          edge_factor,
          size_distribution,
          edge_distribution,
          clip_and_flip,
          scramble_vertex_ids,
          include_edge_weights,
          minimum_weight,
          maximum_weight,
          dtype,
          include_edge_ids,
          include_edge_types,
          min_edge_type_value,
          max_edge_type_value,
          mg,
      )
  
      dfs = []
  
      for edgelist in edgelists:
          src, dst, weights, edge_id, edge_type = edgelist
          df = cudf.DataFrame()
          df["src"] = src
          df["dst"] = dst
          if weights is not None:
              df["weights"] = weights
              weights = "weights"
  
          if edge_id is not None:
              df["edge_id"] = edge_id
              edge_id = "edge_id"
          if edge_type is not None:
              df["edge_type"] = edge_type
              edge_type = "edge_type"
  
          dfs.append(df)
  
      list_G = []
  
      for df in dfs:
          G = cugraph.Graph()
          G.from_cudf_edgelist(
              df,
              source="src",
              destination="dst",
              weight=weights,
              edge_id=edge_id,
              edge_type=edge_type,
          )
          list_G.append(G)
  
      return list_G
  
file_path: cugraph/python/cugraph/cugraph/generators/rmat.py
imports: from dask.distributed import default_client, wait
  import dask_cudf
  from cugraph.dask.comms import comms
  import cudf
  import numpy
  import cupy
  import cugraph
  from pylibcugraph import generate_rmat_edgelist
  from pylibcugraph import generate_rmat_edgelists
  from pylibcugraph import ResourceHandle
label_desc: Use image node_id 8 for calling a global function with example usage: multi_rmat(n_edgelists, min_scale, max_scale, edge_factor, size_distribution, edge_distribution, seed, clip_and_flip, scramble_vertex_ids, include_edge_weights, minimum_weight, maximum_weight, dtype, include_edge_ids, include_edge_types, min_edge_type_value, max_edge_type_value, mg) and returns: list_G