
import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


lowercase        =  {
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

lowercase        =  logging.WARNING



def      __lowerCAmelCase						(							)  ->    str:
							lowerCamelCase_							  =					os.getenv("""DATASETS_VERBOSITY"""			,				UpperCAmelCase__       )
							if env_level_str:
														if env_level_str in log_levels:
																					return log_levels[env_level_str]
														else:
																					logging.getLogger().warning(
																					    F'''Unknown option DATASETS_VERBOSITY={env_level_str}, '''
																					    F'''has to be one of: { ', '.join(log_levels.keys()       ) }'''       )
							return _default_log_level



def      __lowerCAmelCase						(							)  ->    str:
							return __name__.split("""."""       )[0]



def      __lowerCAmelCase						(							)  ->    logging.Logger:
							return logging.getLogger(_get_library_name()       )



def      __lowerCAmelCase						(							)  ->    None:
							# Apply our default configuration to the library root logger.
							lowerCamelCase_							  =					_get_library_root_logger()
							library_root_logger.setLevel(_get_default_logging_level()       )



def      __lowerCAmelCase						(							)  ->    None:
							lowerCamelCase_							  =					_get_library_root_logger()
							library_root_logger.setLevel(logging.NOTSET       )



def      __lowerCAmelCase						(							UpperCAmelCase__				:      Optional[str] = None       )  ->    logging.Logger:
							if name is None:
														lowerCamelCase_							  =					_get_library_name()
							return logging.getLogger(UpperCAmelCase__       )



def      __lowerCAmelCase						(							)  ->    int:
							return _get_library_root_logger().getEffectiveLevel()



def      __lowerCAmelCase						(							UpperCAmelCase__				:      int       )  ->    None:
							_get_library_root_logger().setLevel(UpperCAmelCase__       )



def      __lowerCAmelCase						(							)  ->    Dict:
							return set_verbosity(UpperCAmelCase__       )



def      __lowerCAmelCase						(							)  ->    Tuple:
							return set_verbosity(UpperCAmelCase__       )



def      __lowerCAmelCase						(							)  ->    Dict:
							return set_verbosity(UpperCAmelCase__       )



def      __lowerCAmelCase						(							)  ->    Optional[int]:
							return set_verbosity(UpperCAmelCase__       )



def      __lowerCAmelCase						(							)  ->    None:
							lowerCamelCase_							  =					False



def      __lowerCAmelCase						(							)  ->    None:
							lowerCamelCase_							  =					True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()





class       __A:

					def __init__(	self					:     Union[str, Any]   ,					*__UpperCamelCase					:     Any   ,					**__UpperCamelCase					:     int   ):  # pylint: disable=unused-argument
												lowerCamelCase_							  =					args[0] if args else None

					def __iter__(	self					:     Tuple   ):
												return iter(self._iterator   )

					def __getattr__(	self					:     str   ,					__UpperCamelCase					:     List[str]   ):

												def empty_fn(*__UpperCamelCase					:     List[str]   ,					**__UpperCamelCase					:     str   ):  # pylint: disable=unused-argument
																			return

												return empty_fn

					def __enter__(	self					:     Union[str, Any]   ):
												return self



					def __exit__(	self					:     Optional[Any]   ,					__UpperCamelCase					:     List[str]   ,					__UpperCamelCase					:     str   ,					__UpperCamelCase					:     Dict   ):
												return
lowercase        =  True





class       __A:

					def __call__(	self					:     Any   ,					*__UpperCamelCase					:     str   ,					__UpperCamelCase					:     str=False   ,					**__UpperCamelCase					:     Optional[Any]   ):
												if _tqdm_active and not disable:
																			return tqdm_lib.tqdm(*__UpperCamelCase   ,					**__UpperCamelCase   )
												else:
																			return EmptyTqdm(*__UpperCamelCase   ,					**__UpperCamelCase   )

					def    lowercase__      (	self					:     Optional[Any]   ,					*__UpperCamelCase					:     List[Any]   ,					**__UpperCamelCase					:     List[Any]   ):
												lowerCamelCase_							  =					None
												if _tqdm_active:
																			return tqdm_lib.tqdm.set_lock(*__UpperCamelCase   ,					**__UpperCamelCase   )



					def    lowercase__      (	self					:     List[str]   ):
												if _tqdm_active:
																			return tqdm_lib.tqdm.get_lock()
lowercase        =  _tqdm_cls()



def      __lowerCAmelCase						(							)  ->    bool:
							global _tqdm_active
							return bool(_tqdm_active       )



def      __lowerCAmelCase						(							)  ->    Any:
							global _tqdm_active
							lowerCamelCase_							  =					True



def      __lowerCAmelCase						(							)  ->    Optional[Any]:
							global _tqdm_active
							lowerCamelCase_							  =					False







def      __lowerCAmelCase						(							UpperCAmelCase__				:      int = 4_0_0_0_0_0_0       )  ->    int:
							lowerCamelCase_							  =					[]
							lowerCamelCase_  ,   lowerCamelCase_							  =					0, 1
							while b <= n:
														if b % 2 == 0:
																					even_fibs.append(UpperCAmelCase__       )
														lowerCamelCase_  ,   lowerCamelCase_							  =					b, a + b
							return sum(UpperCAmelCase__       )


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





