

def _a				( SCREAMING_SNAKE_CASE	:    int	)					->					int:

 """simple docstring"""






 barcode //= 10  # exclude the last digit
 __lowerCAmelCase:     str     			=   False
 __lowerCAmelCase:     str     			=   0

 # extract and check each digit
 while barcode != 0:
  __lowerCAmelCase:     Dict     			=   1 if checker else 3
  s += mult * (barcode % 10)
  barcode //= 10
  __lowerCAmelCase:     Optional[Any]     			=   not checker

 return (10 - (s % 10)) % 10







def _a				( SCREAMING_SNAKE_CASE	:    int	)					->					bool:

 """simple docstring"""






 return len(str(SCREAMING_SNAKE_CASE	)	) == 13 and get_check_digit(SCREAMING_SNAKE_CASE	) == barcode % 10







def _a				( SCREAMING_SNAKE_CASE	:    str	)					->					int:

 """simple docstring"""






 if str(SCREAMING_SNAKE_CASE	).isalpha():
  __lowerCAmelCase:     Tuple     			=   f'''Barcode \'{barcode}\' has alphabetic characters.'''
  raise ValueError(SCREAMING_SNAKE_CASE	)
 elif int(SCREAMING_SNAKE_CASE	) < 0:
  raise ValueError('The entered barcode has a negative value. Try again.'	)
 else:
  return int(SCREAMING_SNAKE_CASE	)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      _a	 =     get_barcode(input('''Barcode: ''').strip())

      if is_valid(barcode):
            print(f"'{barcode}' is a valid barcode.")
      else:
            print(f"'{barcode}' is NOT a valid barcode.")








import math






class 							A_				:


     def __init__(							self    :	Any    ,						UpperCAmelCase    :	int    ,						UpperCAmelCase    :	int    ,						UpperCAmelCase    :	int    ,						UpperCAmelCase    :	Any      )							->			Any:
      __lowerCAmelCase:     Optional[Any]     			=   x
      __lowerCAmelCase:     Any     			=   y
      __lowerCAmelCase:     Tuple     			=   step_size
      __lowerCAmelCase:     Dict     			=   function_to_optimize


     def 						UpperCAmelCase						(							self    :	Dict      )							->			int:
      return self.function(self.x    ,						self.y      )


     def 						UpperCAmelCase						(							self    :	str      )							->			int:
      __lowerCAmelCase:     Union[str, Any]     			=   self.step_size
      return [
          SearchProblem(UpperCAmelCase    ,						UpperCAmelCase    ,						UpperCAmelCase    ,						self.function      )
          for x, y in (
              (self.x - step_size, self.y - step_size),
              (self.x - step_size, self.y),
              (self.x - step_size, self.y + step_size),
              (self.x, self.y - step_size),
              (self.x, self.y + step_size),
              (self.x + step_size, self.y - step_size),
              (self.x + step_size, self.y),
              (self.x + step_size, self.y + step_size),
          )
      ]


     def __hash__(							self    :	Optional[Any]      )							->			int:
      return hash(str(self      )      )


     def __eq__(							self    :	Dict    ,						UpperCAmelCase    :	Tuple      )							->			Any:
      if isinstance(UpperCAmelCase    ,						UpperCAmelCase      ):
       return hash(str(self      )      ) == hash(str(UpperCAmelCase      )      )
      return False


     def __str__(							self    :	Optional[Any]      )							->			Dict:
      return F'''x: {self.x} y: {self.y}'''







def _a				( SCREAMING_SNAKE_CASE	:    List[str]					,      SCREAMING_SNAKE_CASE	:    bool = True					,      SCREAMING_SNAKE_CASE	:    float = math.inf					,      SCREAMING_SNAKE_CASE	:    float = -math.inf					,      SCREAMING_SNAKE_CASE	:    float = math.inf					,      SCREAMING_SNAKE_CASE	:    float = -math.inf					,      SCREAMING_SNAKE_CASE	:    bool = False					,      SCREAMING_SNAKE_CASE	:    int = 1_00_00					,      )					->					SearchProblem:

 """simple docstring"""






 __lowerCAmelCase:     Dict     			=   search_prob
 __lowerCAmelCase:     str     			=   []  # list to store the current score at each iteration
 __lowerCAmelCase:     Optional[int]     			=   0
 __lowerCAmelCase:     int     			=   False
 __lowerCAmelCase:     Any     			=   set()
 while not solution_found and iterations < max_iter:
  visited.add(SCREAMING_SNAKE_CASE	)
  iterations += 1
  __lowerCAmelCase:     int     			=   current_state.score()
  scores.append(SCREAMING_SNAKE_CASE	)
  __lowerCAmelCase:     Any     			=   current_state.get_neighbors()
  __lowerCAmelCase:     Tuple     			=   -math.inf
  __lowerCAmelCase:     Any     			=   math.inf
  __lowerCAmelCase:     Dict     			=   None  # to hold the next best neighbor
  for neighbor in neighbors:
   if neighbor in visited:
    continue  # do not want to visit the same state again
   if (
       neighbor.x > max_x
       or neighbor.x < min_x
       or neighbor.y > max_y
       or neighbor.y < min_y
   ):
    continue  # neighbor outside our bounds
   __lowerCAmelCase:     List[str]     			=   neighbor.score() - current_score
   if find_max:  # finding max
    # going to direction with greatest ascent
    if change > max_change and change > 0:
     __lowerCAmelCase:     int     			=   change
     __lowerCAmelCase:     int     			=   neighbor
   else:  # finding min
    # to direction with greatest descent
    if change < min_change and change < 0:
     __lowerCAmelCase:     str     			=   change
     __lowerCAmelCase:     str     			=   neighbor
  if next_state is not None:
   # we found at least one neighbor which improved the current state
   __lowerCAmelCase:     Optional[Any]     			=   next_state
  else:
   # since we have no neighbor that improves the solution we stop the search
   __lowerCAmelCase:     Dict     			=   True

 if visualization:
  from matplotlib import pyplot as plt

  plt.plot(range(SCREAMING_SNAKE_CASE	)					,      SCREAMING_SNAKE_CASE	)
  plt.xlabel('Iterations'	)
  plt.ylabel('Function values'	)
  plt.show()

 return current_state


if __name__ == "__main__":
  import doctest

  doctest.testmod()







  def _a				( SCREAMING_SNAKE_CASE	:    List[str]					,      SCREAMING_SNAKE_CASE	:    List[str]	)					->					Optional[Any]:

   """simple docstring"""






   return (x**2) + (y**2)

  # starting the problem with initial coordinates (3, 4)
  _a	 =     SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
  _a	 =     hill_climbing(prob, find_max=False)
  print(
      '''The minimum score for f(x, y) = x^2 + y^2 found via hill climbing: '''
      f"{local_min.score()}"
  )

  # starting the problem with initial coordinates (12, 47)
  _a	 =     SearchProblem(x=1_2, y=4_7, step_size=1, function_to_optimize=test_fa)
  _a	 =     hill_climbing(
      prob, find_max=False, max_x=1_0_0, min_x=5, max_y=5_0, min_y=-5, visualization=True
  )
  print(
      '''The minimum score for f(x, y) = x^2 + y^2 with the domain 100 > x > 5 '''
      f"and 50 > y > - 5 found via hill climbing: {local_min.score()}"
  )







  def _a				( SCREAMING_SNAKE_CASE	:    Tuple					,      SCREAMING_SNAKE_CASE	:    List[Any]	)					->					Dict:

   """simple docstring"""






   return (3 * x**2) - (6 * y)

  _a	 =     SearchProblem(x=3, y=4, step_size=1, function_to_optimize=test_fa)
  _a	 =     hill_climbing(prob, find_max=True)



  print(
      '''The maximum score for f(x, y) = x^2 + y^2 found via hill climbing: '''
      f"{local_min.score()}"
  )





