code: def do_draw(self, data):
      should_draw = cu.many(
          data,
          min_size=self.min_size,
          max_size=self.max_size,
          average_size=self.average_size,
      )
      seen_sets = tuple(set() for _ in self.keys)
      result = []
  
      remaining = LazySequenceCopy(self.element_strategy.elements)
  
      while remaining and should_draw.more():
          i = len(remaining) - 1
          j = data.draw_integer(0, i)
          if j != i:
              remaining[i], remaining[j] = remaining[j], remaining[i]
          value = self.element_strategy._transform(remaining.pop())
  
          if value is not filter_not_satisfied and all(
              key(value) not in seen
              for key, seen in zip(self.keys, seen_sets)
          ):
              for key, seen in zip(self.keys, seen_sets):
                  seen.add(key(value))
              if self.tuple_suffixes is not None:
                  value = (value, *data.draw(self.tuple_suffixes))
              result.append(value)
          else:
              should_draw.reject(
                  "UniqueSampledListStrategy filter not satisfied or value already seen"
              )
      assert self.max_size >= len(result) >= self.min_size
      return result
  
imports: import copy
  from typing import Any, Iterable, Tuple, overload
  from hypothesis.errors import InvalidArgument
  from hypothesis.internal.conjecture import utils
  from hypothesis.internal.conjecture.junkdrawer import LazySequenceCopy
  from hypothesis.internal.conjecture.utils import combine_labels
  from hypothesis.internal.reflection import is_identity_function
  from hypothesis.strategies._internal.strategies import T3, T4, T5, Ex, MappedSearchStrategy, SearchStrategy, T, check_strategy, filter_not_satisfied
  from hypothesis.strategies._internal.utils import cacheable, defines_strategy
label_desc: Use image node_id 1 for calling the UniqueSampledListStrategy obj's underlying member method code with example usage: obj.do_draw(data) and returns: result