code: 
  
  
  '''simple docstring'''
  
  import math
  from itertools import permutations
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int   )		->					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(_UpperCamelCase   ) + 1   )    ,		6   ):
        if number % i == 0 or number % (i + 2) == 0:
           return False
     return True
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int    ,		_UpperCamelCase      :				list   )		->					bool:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__						,		UpperCamelCase__ 						=						0, len(_UpperCamelCase   ) - 1
     while left <= right:
        UpperCamelCase__ 						=						(left + right) // 2
        if prime_list[middle] == target:
           return True
        elif prime_list[middle] < target:
           UpperCamelCase__ 						=						middle + 1
        else:
           UpperCamelCase__ 						=						middle - 1
  
     return False
  
  
  
  def        SCREAMING_SNAKE_CASE__(		)		->					Union[str, Any]:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						[n for n in range(10_01    ,		1_00_00    ,		2   ) if is_prime(_UpperCamelCase   )]
     UpperCamelCase__ 						=						[]
  
     for number in prime_list:
        UpperCamelCase__ 						=						[]
  
        for prime_member in permutations(list(str(_UpperCamelCase   )   )   ):
           UpperCamelCase__ 						=						int("".join(_UpperCamelCase   )   )
  
           if prime % 2 == 0:
              continue
  
           if search(_UpperCamelCase    ,		_UpperCamelCase   ):
              tmp_numbers.append(_UpperCamelCase   )
  
        tmp_numbers.sort()
        if len(_UpperCamelCase   ) >= 3:
           candidates.append(_UpperCamelCase   )
  
     UpperCamelCase__ 						=						[]
     for candidate in candidates:
        UpperCamelCase__ 						=						len(_UpperCamelCase   )
        UpperCamelCase__ 						=						False
  
        for i in range(_UpperCamelCase   ):
           for j in range(i + 1    ,		_UpperCamelCase   ):
              for k in range(j + 1    ,		_UpperCamelCase   ):
                 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]]   )   )
                    UpperCamelCase__ 						=						True
  
                 if found:
                    break
              if found:
                 break
           if found:
              break
  
     UpperCamelCase__ 						=						set()
     for seq in passed:
        answer.add("".join([str(_UpperCamelCase   ) for i in seq]   )   )
  
     return max(int(_UpperCamelCase   ) for x in answer   )
  
  
  if __name__ == "__main__":
         print(solution())
style_context: 
  
  
  '''simple docstring'''
  
  import unittest
  from functools import partial
  
  import torch
  
  from accelerate import Accelerator, debug_launcher
  from accelerate.state import AcceleratorState, GradientState
  from accelerate.test_utils import require_cpu, require_huggingface_suite
  from accelerate.utils import GradientAccumulationPlugin
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				Any=2    ,		_UpperCamelCase      :				Tuple=True    ,		_UpperCamelCase      :				Union[str, Any]=False   )		->					int:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						Accelerator(step_scheduler_with_optimizer=_UpperCamelCase    ,		split_batches=_UpperCamelCase   )
     UpperCamelCase__ 						=						torch.nn.Linear(2    ,		4   )
     UpperCamelCase__ 						=						torch.optim.AdamW(model.parameters()    ,		lr=1.0   )
     UpperCamelCase__ 						=						torch.optim.lr_scheduler.OneCycleLR(_UpperCamelCase    ,		max_lr=0.0_1    ,		steps_per_epoch=2    ,		epochs=1   )
     UpperCamelCase__						,		UpperCamelCase__						,		UpperCamelCase__ 						=						accelerator.prepare(_UpperCamelCase    ,		_UpperCamelCase    ,		_UpperCamelCase   )
  
     # Optimizer has stepped
     scheduler.step()
     if step_scheduler_with_optimizer or (num_processes == 1):
        assert (
            scheduler.scheduler.last_epoch == num_processes
        ), F'Last Epoch ({scheduler.scheduler.last_epoch}) != Num Processes ({num_processes})'
     else:
        assert (
            scheduler.scheduler.last_epoch != num_processes
        ), F'Last Epoch ({scheduler.scheduler.last_epoch}) == Num Processes ({num_processes})'
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				Optional[int]=2    ,		_UpperCamelCase      :				List[str]=True    ,		_UpperCamelCase      :				Tuple=False   )		->					Optional[Any]:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     UpperCamelCase__ 						=						Accelerator(step_scheduler_with_optimizer=_UpperCamelCase    ,		split_batches=_UpperCamelCase   )
     UpperCamelCase__ 						=						torch.nn.Linear(2    ,		4   )
     UpperCamelCase__ 						=						torch.optim.AdamW(model.parameters()    ,		lr=1.0   )
     UpperCamelCase__ 						=						torch.optim.lr_scheduler.LambdaLR(_UpperCamelCase    ,		lr_lambda=lambda _UpperCamelCase   : 1 - n / 10   )
     UpperCamelCase__						,		UpperCamelCase__						,		UpperCamelCase__ 						=						accelerator.prepare(_UpperCamelCase    ,		_UpperCamelCase    ,		_UpperCamelCase   )
  
     # Optimizer has stepped
     UpperCamelCase__ 						=						False
     scheduler.step()
     UpperCamelCase__ 						=						1 - (num_processes if (step_scheduler_with_optimizer and not split_batches) else 1) / 10
     assert (
         scheduler.get_last_lr()[0] == expected_lr
     ), F'Wrong lr found at first step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}'
  
     # Optimizer has not stepped
     UpperCamelCase__ 						=						True
     scheduler.step()
     if not step_scheduler_with_optimizer:
        UpperCamelCase__ 						=						1 - 2 / 10
     assert (
         scheduler.get_last_lr()[0] == expected_lr
     ), F'Wrong lr found at second step, expected {expected_lr}, got {scheduler.get_last_lr()[0]}'
  
  
  
  def        SCREAMING_SNAKE_CASE__(		_UpperCamelCase      :				int = 2   )		->					Optional[int]:
  
  
  
  
  
     '''simple docstring'''
  
  
  
  
  
  
  
     from transformers import get_linear_schedule_with_warmup
  
     UpperCamelCase__ 						=						[1, 2, 4]
     for num_steps in steps:
        UpperCamelCase__ 						=						GradientAccumulationPlugin(num_steps=_UpperCamelCase    ,		adjust_scheduler=num_steps > 1   )
        UpperCamelCase__ 						=						Accelerator(gradient_accumulation_plugin=_UpperCamelCase   )
        UpperCamelCase__ 						=						torch.nn.Linear(2    ,		4   )
        UpperCamelCase__ 						=						torch.optim.AdamW(model.parameters()    ,		lr=1_0.0   )
        UpperCamelCase__ 						=						get_linear_schedule_with_warmup(optimizer=_UpperCamelCase    ,		num_warmup_steps=0    ,		num_training_steps=20   )
  
        UpperCamelCase__						,		UpperCamelCase__						,		UpperCamelCase__ 						=						accelerator.prepare(_UpperCamelCase    ,		_UpperCamelCase    ,		_UpperCamelCase   )
  
        for i in range(10 * num_steps   ):
           with accelerator.accumulate(_UpperCamelCase   ):
              optimizer.step()
              scheduler.step()
  
           if i == (10 * num_steps - 2):
              assert (
                  scheduler.get_last_lr()[0] != 0
              ), F'Wrong lr found at second-to-last step, expected non-zero, got {scheduler.get_last_lr()[0]}. num_steps: {num_steps}'
        assert (
            scheduler.get_last_lr()[0] == 0
        ), F'Wrong lr found at last step, expected 0, got {scheduler.get_last_lr()[0]}'
        GradientState._reset_state()
  
  
  
  
  
  
  
  @require_cpu
  class  UpperCAmelCase (       unittest.TestCase):
  
   def 		lowercase_						( self :	int					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      debug_launcher(partial(a_,					num_processes=1					),					num_processes=1					)
      debug_launcher(partial(a_,					num_processes=1,					split_batches=a_					),					num_processes=1					)
  
   def 		lowercase_						( self :	Union[str, Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      debug_launcher(partial(a_,					num_processes=1					),					num_processes=1					)
      debug_launcher(partial(a_,					num_processes=1,					split_batches=a_					),					num_processes=1					)
  
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      debug_launcher(partial(a_,					num_processes=1,					step_scheduler_with_optimizer=a_					),					num_processes=1					)
  
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      debug_launcher(partial(a_,					num_processes=1,					step_scheduler_with_optimizer=a_					),					num_processes=1					)
  
   def 		lowercase_						( self :	Optional[int]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      AcceleratorState._reset_state(a_					)
      debug_launcher(a_					)
      debug_launcher(partial(a_,					num_processes=1,					split_batches=a_					),					num_processes=1					)
  
   def 		lowercase_						( self :	Union[str, Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      AcceleratorState._reset_state(a_					)
      debug_launcher(a_					)
      debug_launcher(partial(a_,					num_processes=1,					split_batches=a_					),					num_processes=1					)
  
   def 		lowercase_						( self :	Optional[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      AcceleratorState._reset_state(a_					)
      debug_launcher(partial(a_,					step_scheduler_with_optimizer=a_					)					)
  
   def 		lowercase_						( self :	List[Any]					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      AcceleratorState._reset_state(a_					)
      debug_launcher(partial(a_,					step_scheduler_with_optimizer=a_					)					)
  
   @require_huggingface_suite
   def 		lowercase_						( self :	Any					):
  
  
  
  
  
      """simple docstring"""
  
  
  
      AcceleratorState._reset_state(a_					)
      debug_launcher(partial(a_,					num_processes=1					)					)
      debug_launcher(a_					)