code: def test_anom_mean_raw(abcde):
      a, b, c, d, e = abcde
      g, h = "gh"
      dsk = {
          (d, 0, 0): (f, (a, 0, 0), (b, 1, 0, 0)),
          (d, 1, 0): (f, (a, 1, 0), (b, 1, 1, 0)),
          (d, 2, 0): (f, (a, 2, 0), (b, 1, 2, 0)),
          (d, 3, 0): (f, (a, 3, 0), (b, 1, 3, 0)),
          (d, 4, 0): (f, (a, 4, 0), (b, 1, 4, 0)),
          (a, 0, 0): (f, f, "random_sample", None, (1, 1), [], {}),
          (a, 1, 0): (f, f, "random_sample", None, (1, 1), [], {}),
          (a, 2, 0): (f, f, "random_sample", None, (1, 1), [], {}),
          (a, 3, 0): (f, f, "random_sample", None, (1, 1), [], {}),
          (a, 4, 0): (f, f, "random_sample", None, (1, 1), [], {}),
          (e, 0, 0): (f, (g, 1, 0)),
          (e, 1, 0): (f, (g, 3, 0)),
          (b, 0, 0, 0): (f, (a, 0, 0)),
          (b, 0, 1, 0): (f, (a, 2, 0)),
          (b, 0, 2, 0): (f, (a, 4, 0)),
          (c, 0, 0, 0): (f, (b, 0, 0, 0)),
          (c, 0, 1, 0): (f, (b, 0, 1, 0)),
          (c, 0, 2, 0): (f, (b, 0, 2, 0)),
          (g, 1, 0): (f, [(c, 0, 0, 0), (c, 0, 1, 0), (c, 0, 2, 0)]),
          (b, 2, 0, 0): (f, (a, 1, 0)),
          (b, 2, 1, 0): (f, (a, 3, 0)),
          (c, 1, 0, 0): (f, (b, 2, 0, 0)),
          (c, 1, 1, 0): (f, (b, 2, 1, 0)),
          (g, 3, 0): (f, [(c, 1, 0, 0), (c, 1, 1, 0)]),
          (b, 1, 0, 0): (f, (e, 0, 0)),
          (b, 1, 1, 0): (f, (e, 1, 0)),
          (b, 1, 2, 0): (f, (e, 0, 0)),
          (b, 1, 3, 0): (f, (e, 1, 0)),
          (b, 1, 4, 0): (f, (e, 0, 0)),
          (c, 2, 0, 0): (f, (d, 0, 0)),
          (c, 2, 1, 0): (f, (d, 1, 0)),
          (c, 2, 2, 0): (f, (d, 2, 0)),
          (c, 2, 3, 0): (f, (d, 3, 0)),
          (c, 2, 4, 0): (f, (d, 4, 0)),
          (h, 0, 0): (
              f,
              [(c, 2, 0, 0), (c, 2, 1, 0), (c, 2, 2, 0), (c, 2, 3, 0)],
          ),
          (h, 1, 0): (f, [(c, 2, 4, 0)]),
          (g, 2, 0): (f, [(h, 0, 0), (h, 1, 0)]),
      }
  
      o = order(dsk)
      assert_topological_sort(dsk, o)
      # The left hand computation branch should complete before we start loading
      # more data
      nodes_to_finish_before_loading_more_data = [
          (h, 1, 0),
          (d, 0, 0),
          (d, 2, 0),
          (d, 4, 0),
      ]
      for n in nodes_to_finish_before_loading_more_data:
          assert o[n] < o[(a, 1, 0)]
          assert o[n] < o[(a, 3, 0)]
  
imports: from __future__ import annotations
  import inspect
  import pytest
  import dask
  from dask import delayed
  from dask.base import collections_to_dsk, key_split, visualize_dsk
  from dask.core import get_deps
  from dask.order import _connecting_to_roots, diagnostics, ndependencies, order
  from dask.utils_test import add, inc
label_desc: Use image node_id 38 for calling a global function with example usage: test_anom_mean_raw(abcde) without return types