code: def einsum_helper(draw):
      # Todo: generalize to n equations and arrays
      # Generate unique dimensions for both arrays
      dims_1 = draw(st.integers(min_value=1, max_value=5))
      dims_2 = draw(st.integers(min_value=1, max_value=5))
      eq_1 = draw(
          st.lists(
              st.sampled_from(string.ascii_lowercase),
              min_size=dims_1,
              max_size=dims_1,
              unique=True,
          )
      )
      eq_2 = draw(
          st.lists(
              st.sampled_from(string.ascii_lowercase),
              min_size=dims_2,
              max_size=dims_2,
              unique=True,
          )
      )
  
      # Decide which dimensions are common and update eq_2 accordingly
      common_dims = min(dims_1, dims_2)
      for i in range(common_dims):
          change = draw(st.booleans())
          if change:
              eq_2[i] = eq_1[i]
  
      # Generate shapes according to the dimensions
      shape_1 = [
          draw(st.integers(min_value=1, max_value=5)) for _ in eq_1
      ]
      shape_2 = [
          (
              draw(st.integers(min_value=1, max_value=5))
              if eq_2[i] not in eq_1
              else shape_1[eq_1.index(eq_2[i])]
          )
          for i in range(len(eq_2))
      ]
  
      # Generate arrays and dtypes
      dtype_1, value_1 = draw(
          dtype_and_values(
              available_dtypes=["float64"],
              shape=shape_1,
              min_value=-10,
              max_value=50,
          )
      )
      dtype_2, value_2 = draw(
          dtype_and_values(
              available_dtypes=["float64"],
              shape=shape_2,
              min_value=-10,
              max_value=50,
          )
      )
  
      # Determine output equation
      common_symbols = set(eq_1).intersection(set(eq_2))
      output_eq = []
      if common_symbols:
          output_length = draw(
              st.integers(min_value=1, max_value=len(common_symbols))
          )
          output_eq = draw(
              st.lists(
                  st.sampled_from(list(common_symbols)),
                  min_size=output_length,
                  max_size=output_length,
                  unique=True,
              )
          )
      output_eq = "".join(output_eq)
  
      eq = "".join(eq_1) + "," + "".join(eq_2) + "->" + output_eq
  
      return eq, (value_1[0], value_2[0]), [dtype_1[0], dtype_2[0]]
  
imports: import numpy
  import hypothesis.extra.numpy
  from hypothesis import strategies
  from hypothesis.internal.floats import float_of
  from functools import reduce
  from operator import mul
  import sys
  import string
  import ml_dtypes
  import ivy_tests.test_ivy.helpers.globals
  from ..pipeline_helper import WithBackendContext
  import ivy_tests.test_ivy.helpers
  from ivy_tests.test_ivy.helpers.hypothesis_helpers.dtype_helpers import get_dtypes
  from .None import general_helpers
  from .None import dtype_helpers, number_helpers
  from ..globals import mod_backend
label_desc: Use image node_id 24 for calling a global function with example usage: einsum_helper(draw) and returns: eq,  value_1,  value_2,  list