code: def can_claim_threefold_repetition(self) -> bool:
          
          transposition_key = self._transposition_key()
          transpositions = collections.Counter()  # type: typing.Counter[Hashable]
          transpositions.update((transposition_key, ))
  
          # Count positions.
          switchyard = []
          while self.move_stack:
              move = self.pop()
              switchyard.append(move)
  
              if self.is_irreversible(move):
                  break
  
              transpositions.update((self._transposition_key(), ))
  
          while switchyard:
              self.push(switchyard.pop())
  
          # Threefold repetition occured.
          if transpositions[transposition_key] >= 3:
              return True
  
          # The next legal move is a threefold repetition.
          for move in self.generate_legal_moves():
              self.push(move)
              try:
                  if transpositions[self._transposition_key()] >= 2:
                      return True
              finally:
                  self.pop()
  
          return False
docs: Draw by threefold repetition can be claimed if the position on the
          board occured for the third time or if such a repetition is reached
          with one of the possible legal moves.
  
          Note that checking this can be slow: In the worst case
          scenario every legal move has to be tested and the entire game has to
          be replayed because there is no incremental transposition table.