code: def _swap_optimizer_allows(self, p1, p2):
          
          # setup local shortcuts
          a = self._array
          tile1 = a[p1]
          tile2 = a[p2]
          # 1) disallow same tiles
          if tile1 == tile2:
              return False
          # 2) disallow matches unless a wildcard is involved
          if tile1.matches(tile2) and not any(t.is_wildcard()
                                              for t in (tile1, tile2)):
              return False
          # 3) disallow when both tiles (post-swap) are surrounded by non-matches
          center_other_pairs = ((p1, p2), (p2, p1))
  
          class MatchedTiles(Exception):
              pass
          try:
              for center_p, other_p in center_other_pairs:
                  up_down_left_right = ((center_p[0] - 1, center_p[1]),
                                        (center_p[0] + 1, center_p[1]),
                                        (center_p[0],     center_p[1] - 1),
                                        (center_p[0],     center_p[1] + 1))
                  post_swap_center_tile = a[other_p]
                  for surrounding_p in up_down_left_right:
                      # ignore out of bounds positions
                      # and ignore the inner swap which is handled elsewhere
                      if any((not (0 <= surrounding_p[0] <= 7),  # out of bounds
                              not (0 <= surrounding_p[1] <= 7),  # out of bounds
                              surrounding_p == other_p)):  # inner swap
                          continue
                      surrounding_tile = a[surrounding_p]
                      if post_swap_center_tile.matches(surrounding_tile):
                          raise MatchedTiles()
          except MatchedTiles:
              pass  # if any match found, stop checking and pass this filter
          else:
              return False  # if no match is found, then this can be filtered
          return True
docs: Identify easily discarded meaningless swaps.
  
          This is motivated by the cost of millions of swaps being simulated.