code: def flip_play_game_nosym(self, policy1, policy2):
      # pylint: disable=too-many-branches,too-many-statements,too-many-locals
      # TODO: refactor?
      cards = [i // 4 for i in range(32)]
      np.random.shuffle(cards)
      stack = sorted(cards[:2])
      visible1 = sorted(cards[2:7])
      visible2 = sorted(cards[7:12])
      cards1 = [cards[i] for i in range(12, 22)]
      cards2 = [cards[i] for i in range(22, 32)]
      nan = float("nan")
      something_moves = True
      while something_moves:
          if self.verbose:
              print("==========")
              print(visible1 + [nan] + [len(visible1) + len(cards1)])
              print(stack)
              print(visible2 + [nan] + [len(visible2) + len(cards2)])
              print("==========")
          something_moves = False
  
          bestvalue = self.flip_value(
              visible1,
              visible2,
              len(visible1) + len(cards1),
              len(visible2) + len(cards2),
              stack,
              policy1,
          )
          we_play = False
          for i in range(
              len(visible1)
          ):  # pylint: disable=consider-using-enumerate
              for location in range(2):
                  # print("testing ", visible1[i], " on ", stack[location])
                  if self.flip_match(visible1[i], stack[location]):
                      # print("player 1 can play ", visible1[i], " on ", stack[location])
                      candidate_visible1 = (
                          visible1[:i] + visible1[i + 1 :]
                      )
                      candidate_stack = sorted(
                          [visible1[i], stack[1 - location]]
                      )
                      value = self.flip_value(
                          candidate_visible1,
                          visible2,
                          len(cards1) - 1 + len(visible1),
                          len(cards2) + len(visible2),
                          candidate_stack,
                          policy1,
                      )
                      if value < bestvalue:
                          # print("lgtm")
                          next_visible1 = candidate_visible1
                          bestvalue = value
                          next_stack = candidate_stack
                          we_play = True
          if we_play:
              something_moves = True
              visible1 = sorted(
                  next_visible1 + ([cards1[0]] if cards1 else [])
              )
              stack = sorted(next_stack)
              if cards1:
                  del cards1[0]
              if not visible1:
                  return 1
          bestvalue = self.flip_value(
              visible2,
              visible1,
              len(cards2) + len(visible2),
              len(cards1) + len(visible1),
              stack,
              policy2,
          )
          we_play = False
          for i in range(
              len(visible2)
          ):  # pylint: disable=consider-using-enumerate
              for location in range(2):
                  # print("testing ", visible2[i], " on ", stack[location])
                  if self.flip_match(visible2[i], stack[location]):
                      # print("player 2 can play ", visible2[i], " on ", stack[location])
                      candidate_visible2 = (
                          visible2[:i] + visible2[i + 1 :]
                      )
                      candidate_stack = sorted(
                          [visible2[i], stack[1 - location]]
                      )
                      value = self.flip_value(
                          candidate_visible2,
                          visible1,
                          len(visible2) + len(cards2) - 1,
                          len(visible1) + len(cards1),
                          candidate_stack,
                          policy2,
                      )
                      if value < bestvalue:
                          # print("lgtm")
                          next_visible2 = candidate_visible2
                          bestvalue = value
                          next_stack = candidate_stack
                          we_play = True
          if we_play:
              something_moves = True
              visible2 = sorted(
                  next_visible2 + ([cards2[0]] if cards2 else [])
              )
              stack = sorted(next_stack)
              if cards2:
                  del cards2[0]
                  if not visible2:
                      return 2
          if not something_moves and cards1 and cards2:
              stack = [cards1[0], cards2[0]]
              del cards1[0]
              del cards2[0]
              something_moves = True
      #    print "=========="
      #    print visible1 + [nan] + [len(visible1) + len(cards1)]
      #    print stack
      #    print visible2 + [nan] + [len(visible2) + len(cards2)]
      #    print "=========="
      return (
          1
          if len(visible1) < len(visible2)
          else 2
          if len(visible2) < len(visible1)
          else 0
      )
  
imports: import functools
  import numpy
  from nevergrad.functions import ExperimentFunction
  from nevergrad.parametrization import parameter
label_desc: Use image node_id 9 for calling the _Game obj's underlying member method code with example usage: obj.flip_play_game_nosym(policy1, policy2) and returns: unknown, int, int