code: import math
  from itertools import permutations
  def 				__lowercase	(						lowerCamelCase__					)				->bool:
  
    '''simple docstring'''
  
  
  
  
    if 1 < number < 4:
      # 2 and 3 are primes
      return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
      # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
      return False
  
    # All primes number are in format of 6k +/- 1
    for i in range(5 ,				int(math.sqrt(lowerCamelCase__					) + 1					) ,				6					):
      if number % i == 0 or number % (i + 2) == 0:
        return False
    return True
  def 				__lowercase	(						lowerCamelCase__ ,				lowerCamelCase__					)				->bool:
  
    '''simple docstring'''
  
  
  
  
    a__		,a__     		=     0, len(lowerCamelCase__					) - 1
    while left <= right:
      a__     		=     (left + right) // 2
      if prime_list[middle] == target:
        return True
      elif prime_list[middle] < target:
        a__     		=     middle + 1
      else:
        a__     		=     middle - 1
  
    return False
  def 				__lowercase	(						)				->Dict:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     [n for n in range(10_01 ,				1_00_00 ,				2					) if is_prime(lowerCamelCase__					)]
    a__     		=     []
  
    for number in prime_list:
      a__     		=     []
  
      for prime_member in permutations(list(str(lowerCamelCase__					)					)					):
        a__     		=     int("".join(lowerCamelCase__					)					)
  
        if prime % 2 == 0:
          continue
  
        if search(lowerCamelCase__ ,				lowerCamelCase__					):
          tmp_numbers.append(lowerCamelCase__					)
  
      tmp_numbers.sort()
      if len(lowerCamelCase__					) >= 3:
        candidates.append(lowerCamelCase__					)
  
    a__     		=     []
    for candidate in candidates:
      a__     		=     len(lowerCamelCase__					)
      a__     		=     False
  
      for i in range(lowerCamelCase__					):
        for j in range(i + 1 ,				lowerCamelCase__					):
          for k in range(j + 1 ,				lowerCamelCase__					):
            if (
                abs(candidate[i] - candidate[j]					)
                == abs(candidate[j] - candidate[k]					)
                and len({candidate[i], candidate[j], candidate[k]}					) == 3
            ):
              passed.append(
                  sorted([candidate[i], candidate[j], candidate[k]]					)					)
              a__     		=     True
  
            if found:
              break
          if found:
            break
        if found:
          break
  
    a__     		=     set()
    for seq in passed:
      answer.add("".join([str(lowerCamelCase__					) for i in seq]					)					)
  
    return max(int(lowerCamelCase__					) for x in answer					)
  
  
  if __name__ == "__main__":
       print(solution())
  
  
style_context: from unittest.mock import patch
  
  import datasets
  from datasets import Dataset
  def 				__lowercase	(						)				->Union[str, Any]:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     Dataset.from_dict({"col_1": [3, 2, 0, 1]}					)
  
    with patch("tqdm.auto.tqdm"					) as mock_tqdm:
      datasets.disable_progress_bar()
      dset.map(lambda lowerCamelCase__					: {"col_2": x["col_1"] + 1}					)
      mock_tqdm.assert_not_called()
  
      mock_tqdm.reset_mock()
  
      datasets.enable_progress_bar()
      dset.map(lambda lowerCamelCase__					: {"col_2": x["col_1"] + 1}					)
      mock_tqdm.assert_called()
  
  