code: def get_first_solve_batch_matrix(draw, choose_adjoint=False):
      """Generate non-singular left hand side of equation system possibly with a
      single batch dimension at the beginning. Use get_second_solve_batch_matrix
      to get the right hand side.
  
      Parameters
      ----------
      choose_adjoint
          if True, randomly generates boolean
          value for adjoint output,
          otherwise this output is False
  
      Returns
      -------
          dtype
              Data type of the array
          matrix
              Generated array
          adjoint
              boolean value specifying whether the system should be solved for
              adjoint of array
      """
      # float16 causes a crash when filtering out matrices
      # for which `np.linalg.cond` is large.
      input_dtype_strategy = st.shared(
          st.sampled_from(draw(helpers.get_dtypes("float"))).filter(
              lambda x: "float16" not in x
          ),
          key="shared_dtype",
      )
      input_dtype = draw(input_dtype_strategy)
  
      shared_size = draw(
          st.shared(
              helpers.ints(min_value=2, max_value=4), key="shared_size"
          )
      )
      batch_size = draw(
          st.shared(
              helpers.ints(min_value=0, max_value=3),
              key="shared_batch_size",
          )
      )
  
      # adjoint of a regular matrix is also regular
      matrix = draw(
          helpers.array_values(
              dtype=input_dtype,
              shape=tuple(
                  ([] if batch_size == 0 else [batch_size])
                  + [shared_size, shared_size]
              ),
              min_value=2,
              max_value=5,
          ).filter(
              lambda x: np.all(
                  np.linalg.cond(x) < 1 / sys.float_info.epsilon
              )
          )
      )
  
      adjoint = False
      if choose_adjoint:
          adjoint = draw(st.booleans())
  
      return input_dtype, matrix, adjoint
  
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 26 for calling a global function with example usage: get_first_solve_batch_matrix(draw, choose_adjoint) and returns: input_dtype,  matrix,  adjoint