import unittest
from dataclasses import dataclass
from typing import Optional

from transformers.utils import ModelOutput







@dataclass
class        UpperCAmelCase_					(				_a     ):
    UpperCAmelCase_      :							float
    UpperCAmelCase_      :							Optional[float]    			=				None
    UpperCAmelCase_      :							Optional[float]    			=				None







class        UpperCAmelCase_					(				unittest.TestCase     ):




    def     __lowerCamelCase			(       self	: str )						->			Dict:
      a__  		=  ModelOutputTest(a=30 )
      self.assertEqual(x.a   ,   30 )
      self.assertIsNone(x.b )
      self.assertIsNone(x.c )
      with self.assertRaises(lowerCAmelCase ):
        a__  		=  x.d




    def     __lowerCamelCase			(       self	: Tuple )						->			List[Any]:
      a__  		=  ModelOutputTest(a=30   ,   b=10 )
      self.assertEqual(x[0]   ,   30 )
      self.assertEqual(x[1]   ,   10 )
      self.assertEqual(x[:2]   ,   (30, 10) )
      self.assertEqual(x[:]   ,   (30, 10) )

      a__  		=  ModelOutputTest(a=30   ,   c=10 )
      self.assertEqual(x[0]   ,   30 )
      self.assertEqual(x[1]   ,   10 )
      self.assertEqual(x[:2]   ,   (30, 10) )
      self.assertEqual(x[:]   ,   (30, 10) )




    def     __lowerCamelCase			(       self	: Optional[int] )						->			Union[str, Any]:
      a__  		=  ModelOutputTest(a=30   ,   b=10 )
      self.assertEqual(x["a"]   ,   30 )
      self.assertEqual(x["b"]   ,   10 )
      with self.assertRaises(lowerCAmelCase ):
        a__  		=  x["c"]

      a__  		=  ModelOutputTest(a=30   ,   c=10 )
      self.assertEqual(x["a"]   ,   30 )
      self.assertEqual(x["c"]   ,   10 )
      with self.assertRaises(lowerCAmelCase ):
        a__  		=  x["b"]




    def     __lowerCamelCase			(       self	: Optional[int] )						->			List[str]:
      a__  		=  ModelOutputTest(a=30 )
      self.assertEqual(list(x.keys() )   ,   ["a"] )
      self.assertEqual(list(x.values() )   ,   [30] )
      self.assertEqual(list(x.items() )   ,   [("a", 30)] )
      self.assertEqual(list(lowerCAmelCase )   ,   ["a"] )

      a__  		=  ModelOutputTest(a=30   ,   b=10 )
      self.assertEqual(list(x.keys() )   ,   ["a", "b"] )
      self.assertEqual(list(x.values() )   ,   [30, 10] )
      self.assertEqual(list(x.items() )   ,   [("a", 30), ("b", 10)] )
      self.assertEqual(list(lowerCAmelCase )   ,   ["a", "b"] )

      a__  		=  ModelOutputTest(a=30   ,   c=10 )
      self.assertEqual(list(x.keys() )   ,   ["a", "c"] )
      self.assertEqual(list(x.values() )   ,   [30, 10] )
      self.assertEqual(list(x.items() )   ,   [("a", 30), ("c", 10)] )
      self.assertEqual(list(lowerCAmelCase )   ,   ["a", "c"] )

      with self.assertRaises(lowerCAmelCase ):
        a__  		=  x.update({"d": 20} )
      with self.assertRaises(lowerCAmelCase ):
        del x["a"]
      with self.assertRaises(lowerCAmelCase ):
        a__  		=  x.pop("a" )
      with self.assertRaises(lowerCAmelCase ):
        a__  		=  x.setdefault("d"   ,   32 )




    def     __lowerCamelCase			(       self	: Optional[Any] )						->			Dict:
      a__  		=  ModelOutputTest(a=30 )
      a__  		=  10
      self.assertEqual(x.a   ,   10 )
      self.assertEqual(x["a"]   ,   10 )




    def     __lowerCamelCase			(       self	: str )						->			List[Any]:
      a__  		=  ModelOutputTest(a=30 )
      a__  		=  10
      self.assertEqual(x.a   ,   10 )
      self.assertEqual(x["a"]   ,   10 )




    def     __lowerCamelCase			(       self	: str )						->			int:
      a__  		=  ModelOutputTest({"a": 30, "b": 10} )
      self.assertEqual(list(x.keys() )   ,   ["a", "b"] )
      self.assertEqual(x.a   ,   30 )
      self.assertEqual(x.b   ,   10 )




    def     __lowerCamelCase			(       self	: Union[str, Any] )						->			Tuple:
      a__  		=  ModelOutputTest([("a", 30), ("b", 10)] )
      self.assertEqual(list(x.keys() )   ,   ["a", "b"] )
      self.assertEqual(x.a   ,   30 )
      self.assertEqual(x.b   ,   10 )

      with self.assertRaises(lowerCAmelCase ):
        a__  		=  ModelOutputTest([("a", 30), (10, 10)] )

      a__  		=  ModelOutputTest(a=(30, 30) )
      self.assertEqual(list(x.keys() )   ,   ["a"] )
      self.assertEqual(x.a   ,   (30, 30) )


import math
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__ = 2_00_00_00       )					->int:

  '''simple docstring'''




  return sum(num for num in range(3			,					lowerCamelCase__			,					2       ) if is_prime(lowerCamelCase__       )       ) + 2 if n > 2 else 0


if __name__ == "__main__":
     print(F"""{solution() = }""")

