


'''simple docstring'''

# Lint as: python3
import dataclasses
import re
from dataclasses import dataclass
from functools import total_ordering
from typing import Optional, Union


lowercase__				     =		re.compile(R"^(?P<major>\d+)" R"\.(?P<minor>\d+)" R"\.(?P<patch>\d+)$")





@total_ordering
@dataclass
class 						__SCREAMING_SNAKE_CASE					:
     UpperCAmelCase 					=				42
     UpperCAmelCase 					=				None
     UpperCAmelCase 					=				None
     UpperCAmelCase 					=				None
     UpperCAmelCase 					=				None






     def  a_					(			self		)       ->    Union[str, Any]:
          _a			,			_a			,			_a						=		_str_to_version_tuple(self.version_str		)






     def __repr__(			self		)       ->    Dict:
          return f"{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}"






     @property
     def  a_					(			self		)       ->    Optional[int]:
          return self.major, self.minor, self.patch






     def  a_					(			self     ,							__UpperCamelCase		)       ->    Optional[Any]:
          if isinstance(__UpperCamelCase     ,							__UpperCamelCase		):
               return Version(__UpperCamelCase		)
          elif isinstance(__UpperCamelCase     ,							__UpperCamelCase		):
               return other
          raise TypeError(f"{other} (type {type(__UpperCamelCase		)}) cannot be compared to version."		)






     def __eq__(			self     ,							__UpperCamelCase		)       ->    Dict:
          try:
               _a						=		self._validate_operand(__UpperCamelCase		)
          except (TypeError, ValueError):
               return False
          else:
               return self.tuple == other.tuple






     def __lt__(			self     ,							__UpperCamelCase		)       ->    Union[str, Any]:
          _a						=		self._validate_operand(__UpperCamelCase		)
          return self.tuple < other.tuple






     def __hash__(			self		)       ->    List[Any]:
          return hash(_version_tuple_to_str(self.tuple		)		)






     @classmethod
     def  a_					(			cls     ,							__UpperCamelCase		)       ->    Optional[Any]:
          _a						=		{f.name for f in dataclasses.fields(cls		)}
          return cls(**{k: v for k, v in dic.items() if k in field_names}		)






     def  a_					(			self		)       ->    str:
          return self.version_str







def __UpperCamelCase   (			__lowerCamelCase		: Union[str, Any]				)      ->     List[str]:







     '''simple docstring'''






     _a						=		_VERSION_REG.match(__lowerCamelCase				)
     if not res:
          raise ValueError(F"Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits."				)
     return tuple(int(__lowerCamelCase				) for v in [res.group("major"				), res.group("minor"				), res.group("patch"				)]				)






def __UpperCamelCase   (			__lowerCamelCase		: str				)      ->     Tuple:







     '''simple docstring'''






     return ".".join(str(__lowerCamelCase				) for v in version_tuple				)





'''simple docstring'''

def __UpperCamelCase   (			__lowerCamelCase		: int = 400_0000				)      ->     int:







     '''simple docstring'''






     _a						=		[]
     _a			,			_a						=		0, 1
     while b <= n:
          if b % 2 == 0:
               even_fibs.append(__lowerCamelCase				)
          _a			,			_a						=		b, a + b
     return sum(__lowerCamelCase				)


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

