code: def _draw_loop_dimensions(self, data, use=None):
      # All shapes are handled in column-major order; i.e. they are reversed
      base_shape = self.base_shape[::-1]
      result_shape = list(base_shape)
      shapes = [[] for _ in range(self.num_shapes)]
      if use is None:
          use = [True for _ in range(self.num_shapes)]
      else:
          assert len(use) == self.num_shapes
          assert all(isinstance(x, bool) for x in use)
  
      for dim_count in range(1, self.max_dims + 1):
          dim = dim_count - 1
  
          # We begin by drawing a valid dimension-size for the given
          # dimension. This restricts the variability across the shapes
          # at this dimension such that they can only choose between
          # this size and a singleton dimension.
          if len(base_shape) < dim_count or base_shape[dim] == 1:
              # dim is unrestricted by the base-shape: shrink to min_side
              dim_side = data.draw(self.side_strat)
          elif base_shape[dim] <= self.max_side:
              # dim is aligned with non-singleton base-dim
              dim_side = base_shape[dim]
          else:
              # only a singleton is valid in alignment with the base-dim
              dim_side = 1
  
          for shape_id, shape in enumerate(shapes):
              # Populating this dimension-size for each shape, either
              # the drawn size is used or, if permitted, a singleton
              # dimension.
              if dim_count <= len(base_shape) and self.size_one_allowed:
                  # aligned: shrink towards size 1
                  side = data.draw(st.sampled_from([1, dim_side]))
              else:
                  side = dim_side
  
              # Use a trick where where a biased coin is queried to see
              # if the given shape-tuple will continue to be grown. All
              # of the relevant draws will still be made for the given
              # shape-tuple even if it is no longer being added to.
              # This helps to ensure more stable shrinking behavior.
              if self.min_dims < dim_count:
                  use[shape_id] &= cu.biased_coin(
                      data, 1 - 1 / (1 + self.max_dims - dim)
                  )
  
              if use[shape_id]:
                  shape.append(side)
                  if len(result_shape) < len(shape):
                      result_shape.append(shape[-1])
                  elif shape[-1] != 1 and result_shape[dim] == 1:
                      result_shape[dim] = shape[-1]
          if not any(use):
              break
  
      result_shape = result_shape[
          : max(map(len, [self.base_shape] + shapes))
      ]
  
      assert len(shapes) == self.num_shapes
      assert all(
          self.min_dims <= len(s) <= self.max_dims for s in shapes
      )
      assert all(
          self.min_side <= s <= self.max_side
          for side in shapes
          for s in side
      )
  
      return BroadcastableShapes(
          input_shapes=tuple(
              tuple(reversed(shape)) for shape in shapes
          ),
          result_shape=tuple(reversed(result_shape)),
      )
  
imports: from __future__ import absolute_import, division, print_function
  import math
  import re
  from collections import namedtuple
  import numpy
  import hypothesis.internal.conjecture.utils
  import hypothesis.strategies._internal.core
  from hypothesis import Verbosity, assume
  from hypothesis._settings import note_deprecation
  from hypothesis.errors import InvalidArgument
  from hypothesis.internal.compat import PY2, hrange, integer_types, quiet_raise, string_types
  from hypothesis.internal.coverage import check_function
  from hypothesis.internal.reflection import proxies, reserved_means_kwonly_star
  from hypothesis.internal.validation import check_type, check_valid_interval
  from hypothesis.reporting import current_verbosity
  from hypothesis.strategies._internal import SearchStrategy
  from hypothesis.utils.conventions import UniqueIdentifier, not_set
label_desc: Use image node_id 4 for calling the MutuallyBroadcastableShapesStrategy obj's underlying member method code with example usage: obj._draw_loop_dimensions(data, use) and returns: BroadcastableShapes