


'''simple docstring'''



__A		=[4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
__A		=[3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
__A		={
    0: 'Sunday',
    1: 'Monday',
    2: 'Tuesday',
    3: 'Wednesday',
    4: 'Thursday',
    5: 'Friday',
    6: 'Saturday',
}







def 			_UpperCamelCase					(						UpperCamelCase__       ,					UpperCamelCase__       ,					UpperCamelCase__    ):
			assert len(str(UpperCamelCase__    )    ) > 2, "year should be in YYYY format"
			assert 1 <= month <= 1_2, "month should be between 1 to 12"
			assert 1 <= day <= 3_1, "day should be between 1 to 31"

			# Doomsday algorithm:
			UpperCAmelCase__     :    Any         =   year // 1_0_0
			UpperCAmelCase__     :    Dict         =   (5 * (century % 4) + 2) % 7
			UpperCAmelCase__     :    Union[str, Any]         =   year % 1_0_0
			UpperCAmelCase__     :    Dict         =   centurian % 1_2
			UpperCAmelCase__     :    int         =   (
			    (centurian // 1_2) + centurian_m + (centurian_m // 4) + century_anchor
			) % 7
			UpperCAmelCase__     :    List[Any]         =   (
			    DOOMSDAY_NOT_LEAP[month - 1]
			    if (year % 4 != 0) or (centurian == 0 and (year % 4_0_0) == 0)
			    else DOOMSDAY_LEAP[month - 1]
			)
			UpperCAmelCase__     :    Tuple         =   (dooms_day + day - day_anchor) % 7
			return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
		import doctest

		doctest.testmod()







import math
def 						_a    (      a :int )							->			list:
 a		  =      [True] * n
 a		  =      False
 a		  =      False
 a		  =      True

 for i in range(3	,							int(n**0.5 + 1 )	,							2 ):
  a		  =      i * 2
  while index < n:
   a		  =      False
   a		  =      index + i

 a		  =      [2]

 for i in range(3	,							a	,							2 ):
  if is_prime[i]:
   primes.append(a )

 return primes
def 						_a    (      a :int = 999_966_663_333 )							->			int:
 a		  =      math.floor(math.sqrt(a ) ) + 100
 a		  =      prime_sieve(a )

 a		  =      0
 a		  =      0
 a		  =      primes[prime_index]

 while (last_prime**2) <= limit:
  a		  =      primes[prime_index + 1]

  a		  =      last_prime**2
  a		  =      next_prime**2

  # Get numbers divisible by lps(current)
  a		  =      lower_bound + last_prime
  while upper_bound > current <= limit:
   matches_sum += current
   current += last_prime

  # Reset the upper_bound
  while (upper_bound - next_prime) > limit:
   upper_bound -= next_prime

  # Add the numbers divisible by ups(current)
  a		  =      upper_bound - next_prime
  while current > lower_bound:
   matches_sum += current
   current -= next_prime

  # Remove the numbers divisible by both ups and lps
  a		  =      0
  while upper_bound > current <= limit:
   if current <= lower_bound:
    # Increment the current number
    current += last_prime * next_prime
    continue

   if current > limit:
    break

   # Remove twice since it was added by both ups and lps
   matches_sum -= current * 2

   # Increment the current number
   current += last_prime * next_prime

  # Setup for next pair
  a		  =      next_prime
  prime_index += 1

 return matches_sum


if __name__ == "__main__":
     print(solution())


