






import os
from pickle import UnpicklingError
from typing import Dict, Tuple

import jax
import jax.numpy as jnp
import numpy as np
from flax.serialization import from_bytes
from flax.traverse_util import flatten_dict, unflatten_dict

import transformers

from .utils import logging


__A					=	logging.get_logger(__name__)







def       lowercase__	(					A_:						Any  ,      A_:						Tuple  ,      A_:						Tuple  ,      A_:						Dict=False		)	->				Any:







       """simple docstring"""






       try:
              import torch  # noqa: F401
       except ImportError:
              logger.error(
                  """Loading a PyTorch model in Flax, requires both PyTorch and Flax to be installed. Please see"""
                  """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
                  """ instructions."""		)
              raise

       if not is_sharded:
              __UpperCAmelCase     				=os.path.abspath(A_		)
              logger.info(F'''Loading PyTorch weights from {pt_path}'''		)

              __UpperCAmelCase     				=torch.load(A_  ,      map_location="""cpu"""		)
              logger.info(F'''PyTorch checkpoint contains {sum(t.numel() for t in pt_state_dict.values()		):,} parameters.'''		)

              __UpperCAmelCase     				=convert_pytorch_state_dict_to_flax(A_  ,      A_		)
       else:
              # model is sharded and pytorch_checkpoint_path already contains the list of .pt shard files
              __UpperCAmelCase     				=convert_pytorch_sharded_state_dict_to_flax(A_  ,      A_		)
       return flax_state_dict







def       lowercase__	(					A_:						Tuple[str]  ,      A_:						np.ndarray  ,      A_:						Dict[str, jnp.ndarray]  ,      A_:						str  ,      )	->				(Tuple[str], np.ndarray):







       """simple docstring"""






       def is_key_or_prefix_key_in_dict(A_:						Tuple[str]		) -> bool:
              return len(set(A_		) & {key, (model_prefix,) + key}		) > 0

       # layer norm
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""scale""",)
       if pt_tuple_key[-1] in ["weight", "gamma"] and is_key_or_prefix_key_in_dict(A_		):
              return renamed_pt_tuple_key, pt_tensor

       # batch norm layer mean
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""mean""",)
       if pt_tuple_key[-1] == "running_mean" and not is_key_or_prefix_key_in_dict(A_		):
              return renamed_pt_tuple_key, pt_tensor

       # batch norm layer var
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""var""",)
       if pt_tuple_key[-1] == "running_var" and not is_key_or_prefix_key_in_dict(A_		):
              return renamed_pt_tuple_key, pt_tensor

       # embedding
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""embedding""",)
       if pt_tuple_key[-1] == "weight" and is_key_or_prefix_key_in_dict(A_		):
              return renamed_pt_tuple_key, pt_tensor

       # conv layer
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""kernel""",)
       if pt_tuple_key[-1] == "weight" and pt_tensor.ndim == 4 and not is_key_or_prefix_key_in_dict(A_		):
              __UpperCAmelCase     				=pt_tensor.transpose(2  ,      3  ,      1  ,      0		)
              return renamed_pt_tuple_key, pt_tensor

       # linear layer
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""kernel""",)
       if pt_tuple_key[-1] == "weight" and not is_key_or_prefix_key_in_dict(A_		):
              __UpperCAmelCase     				=pt_tensor.T
              return renamed_pt_tuple_key, pt_tensor

       # old PyTorch layer norm weight
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""weight""",)
       if pt_tuple_key[-1] == "gamma":
              return renamed_pt_tuple_key, pt_tensor

       # old PyTorch layer norm bias
       __UpperCAmelCase     				=pt_tuple_key[:-1] + ("""bias""",)
       if pt_tuple_key[-1] == "beta":
              return renamed_pt_tuple_key, pt_tensor

       # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
       __UpperCAmelCase     				=None
       if pt_tuple_key[-3::2] == ("parametrizations", "original0"):
              __UpperCAmelCase     				=pt_tuple_key[-2] + """_g"""
       elif pt_tuple_key[-3::2] == ("parametrizations", "original1"):
              __UpperCAmelCase     				=pt_tuple_key[-2] + """_v"""
       if name is not None:
              __UpperCAmelCase     				=pt_tuple_key[:-3] + (name,)
              return renamed_pt_tuple_key, pt_tensor

       return pt_tuple_key, pt_tensor







def       lowercase__	(					A_:						str  ,      A_:						int		)	->				str:







       """simple docstring"""






       __UpperCAmelCase     				={k: v.numpy() for k, v in pt_state_dict.items()}

       __UpperCAmelCase     				=flax_model.base_model_prefix

       # use params dict if the model contains batch norm layers
       if "params" in flax_model.params:
              __UpperCAmelCase     				=flax_model.params["""params"""]
       else:
              __UpperCAmelCase     				=flax_model.params
       __UpperCAmelCase     				=flatten_dict(A_		)

       # add batch_stats keys,values to dict
       if "batch_stats" in flax_model.params:
              __UpperCAmelCase     				=flatten_dict(flax_model.params["""batch_stats"""]		)
              random_flax_state_dict.update(A_		)

       __UpperCAmelCase     				={}

       __UpperCAmelCase     				=(model_prefix not in flax_model_params) and (
           model_prefix in {k.split("""."""		)[0] for k in pt_state_dict.keys()}
       )
       __UpperCAmelCase     				=(model_prefix in flax_model_params) and (
           model_prefix not in {k.split("""."""		)[0] for k in pt_state_dict.keys()}
       )

       # Need to change some parameters name to match Flax names
       for pt_key, pt_tensor in pt_state_dict.items():
              __UpperCAmelCase     				=tuple(pt_key.split("""."""		)		)

              # remove base model prefix if necessary
              __UpperCAmelCase     				=pt_tuple_key[0] == model_prefix
              if load_model_with_head_into_base_model and has_base_model_prefix:
                     __UpperCAmelCase     				=pt_tuple_key[1:]

              # Correctly rename weight parameters
              __UpperCAmelCase				, __UpperCAmelCase     				=rename_key_and_reshape_tensor(
                  A_  ,      A_  ,      A_  ,      A_		)

              # add model prefix if necessary
              __UpperCAmelCase     				=(model_prefix,) + flax_key in random_flax_state_dict
              if load_base_model_into_model_with_head and require_base_model_prefix:
                     __UpperCAmelCase     				=(model_prefix,) + flax_key

              if flax_key in random_flax_state_dict:
                     if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                            raise ValueError(
                                F'''PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '''
                                F'''{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'''		)

        # add batch stats if the model contains batchnorm layers
              if "batch_stats" in flax_model.params:
                     if "mean" in flax_key[-1] or "var" in flax_key[-1]:
                            __UpperCAmelCase     				=jnp.asarray(A_		)
                            continue
                     # remove num_batches_tracked key
                     if "num_batches_tracked" in flax_key[-1]:
                            flax_state_dict.pop(A_  ,      A_		)
                            continue

                     # also add unexpected weight so that warning is thrown
                     __UpperCAmelCase     				=jnp.asarray(A_		)

              else:
                     # also add unexpected weight so that warning is thrown
                     __UpperCAmelCase     				=jnp.asarray(A_		)

       return unflatten_dict(A_		)







def       lowercase__	(					A_:						Union[str, Any]  ,      A_:						List[str]		)	->				Optional[Any]:







       """simple docstring"""






       import torch

       # Load the index
       __UpperCAmelCase     				={}
       for shard_file in shard_filenames:
              # load using msgpack utils
              __UpperCAmelCase     				=torch.load(A_		)
              __UpperCAmelCase     				={k: v.numpy() for k, v in pt_state_dict.items()}

              __UpperCAmelCase     				=flax_model.base_model_prefix

              # use params dict if the model contains batch norm layers and then add batch_stats keys,values to dict
              if "batch_stats" in flax_model.params:
                     __UpperCAmelCase     				=flax_model.params["""params"""]

                     __UpperCAmelCase     				=flatten_dict(A_		)
                     random_flax_state_dict.update(flatten_dict(flax_model.params["""batch_stats"""]		)		)
              else:
                     __UpperCAmelCase     				=flax_model.params
                     __UpperCAmelCase     				=flatten_dict(A_		)

              __UpperCAmelCase     				=(model_prefix not in flax_model_params) and (
                  model_prefix in {k.split("""."""		)[0] for k in pt_state_dict.keys()}
              )
              __UpperCAmelCase     				=(model_prefix in flax_model_params) and (
                  model_prefix not in {k.split("""."""		)[0] for k in pt_state_dict.keys()}
              )
              # Need to change some parameters name to match Flax names
              for pt_key, pt_tensor in pt_state_dict.items():
                     __UpperCAmelCase     				=tuple(pt_key.split("""."""		)		)

                     # remove base model prefix if necessary
                     __UpperCAmelCase     				=pt_tuple_key[0] == model_prefix
                     if load_model_with_head_into_base_model and has_base_model_prefix:
                            __UpperCAmelCase     				=pt_tuple_key[1:]

                     # Correctly rename weight parameters
                     __UpperCAmelCase				, __UpperCAmelCase     				=rename_key_and_reshape_tensor(
                         A_  ,      A_  ,      A_  ,      A_		)
                     # add model prefix if necessary
                     __UpperCAmelCase     				=(model_prefix,) + flax_key in random_flax_state_dict
                     if load_base_model_into_model_with_head and require_base_model_prefix:
                            __UpperCAmelCase     				=(model_prefix,) + flax_key

                     if flax_key in random_flax_state_dict:
                            if flax_tensor.shape != random_flax_state_dict[flax_key].shape:
                                   raise ValueError(
                                       F'''PyTorch checkpoint seems to be incorrect. Weight {pt_key} was expected to be of shape '''
                                       F'''{random_flax_state_dict[flax_key].shape}, but is {flax_tensor.shape}.'''		)

            # add batch stats if the model contains batchnorm layers
                     if "batch_stats" in flax_model.params:
                            if "mean" in flax_key[-1]:
                                   __UpperCAmelCase     				=jnp.asarray(A_		)
                                   continue
                            if "var" in flax_key[-1]:
                                   __UpperCAmelCase     				=jnp.asarray(A_		)
                                   continue
                            # remove num_batches_tracked key
                            if "num_batches_tracked" in flax_key[-1]:
                                   flax_state_dict.pop(A_  ,      A_		)
                                   continue

                            # also add unexpected weight so that warning is thrown
                            __UpperCAmelCase     				=jnp.asarray(A_		)

                     else:
                            # also add unexpected weight so that warning is thrown
                            __UpperCAmelCase     				=jnp.asarray(A_		)
       return unflatten_dict(A_		)







def       lowercase__	(					A_:						int  ,      A_:						Tuple		)	->				str:







       """simple docstring"""






       __UpperCAmelCase     				=os.path.abspath(A_		)
       logger.info(F'''Loading Flax weights from {flax_checkpoint_path}'''		)

       # import correct flax class
       __UpperCAmelCase     				=getattr(A_  ,      """Flax""" + model.__class__.__name__		)

       # load flax weight dict
       with open(A_  ,      """rb"""		) as state_f:
              try:
                     __UpperCAmelCase     				=from_bytes(A_  ,      state_f.read()		)
              except UnpicklingError:
                     raise EnvironmentError(F'''Unable to convert {flax_checkpoint_path} to Flax deserializable object. '''		)

       return load_flax_weights_in_pytorch_model(A_  ,      A_		)







def       lowercase__	(					A_:						List[Any]  ,      A_:						Union[str, Any]		)	->				int:







       """simple docstring"""






       try:
              import torch  # noqa: F401
       except ImportError:
              logger.error(
                  """Loading a Flax weights in PyTorch, requires both PyTorch and Flax to be installed. Please see"""
                  """ https://pytorch.org/ and https://flax.readthedocs.io/en/latest/installation.html for installation"""
                  """ instructions."""		)
              raise

       # check if we have bf16 weights
       __UpperCAmelCase     				=flatten_dict(jax.tree_util.tree_map(lambda A_		: x.dtype == jnp.bfloataa  ,      A_		)		).values()
       if any(A_		):
              # convert all weights to fp32 if the are bf16 since torch.from_numpy can-not handle bf16
              # and bf16 is not fully supported in PT yet.
              logger.warning(
                  """Found ``bfloat16`` weights in Flax model. Casting all ``bfloat16`` weights to ``float32`` """
                  """before loading those in PyTorch model."""		)
              __UpperCAmelCase     				=jax.tree_util.tree_map(
                  lambda A_		: params.astype(np.floataa		) if params.dtype == jnp.bfloataa else params  ,      A_		)

       __UpperCAmelCase     				=flatten_dict(A_		)
       __UpperCAmelCase     				=pt_model.state_dict()

       __UpperCAmelCase     				=(pt_model.base_model_prefix in flax_state) and (
           pt_model.base_model_prefix not in {k.split("""."""		)[0] for k in pt_model_dict.keys()}
       )
       __UpperCAmelCase     				=(pt_model.base_model_prefix not in flax_state) and (
           pt_model.base_model_prefix in {k.split("""."""		)[0] for k in pt_model_dict.keys()}
       )

       # keep track of unexpected & missing keys
       __UpperCAmelCase     				=[]
       __UpperCAmelCase     				=set(pt_model_dict.keys()		)

       for flax_key_tuple, flax_tensor in flax_state_dict.items():
              __UpperCAmelCase     				=flax_key_tuple[0] == pt_model.base_model_prefix
              __UpperCAmelCase     				=""".""".join((pt_model.base_model_prefix,) + flax_key_tuple		) in pt_model_dict

              # adapt flax_key to prepare for loading from/to base model only
              if load_model_with_head_into_base_model and has_base_model_prefix:
                     __UpperCAmelCase     				=flax_key_tuple[1:]
              elif load_base_model_into_model_with_head and require_base_model_prefix:
                     __UpperCAmelCase     				=(pt_model.base_model_prefix,) + flax_key_tuple

              # rename flax weights to PyTorch format
              if flax_key_tuple[-1] == "kernel" and flax_tensor.ndim == 4 and ".".join(A_		) not in pt_model_dict:
                     # conv layer
                     __UpperCAmelCase     				=flax_key_tuple[:-1] + ("""weight""",)
                     __UpperCAmelCase     				=jnp.transpose(A_  ,      (3, 2, 0, 1)		)
              elif flax_key_tuple[-1] == "kernel" and ".".join(A_		) not in pt_model_dict:
                     # linear layer
                     __UpperCAmelCase     				=flax_key_tuple[:-1] + ("""weight""",)
                     __UpperCAmelCase     				=flax_tensor.T
              elif flax_key_tuple[-1] in ["scale", "embedding"]:
                     __UpperCAmelCase     				=flax_key_tuple[:-1] + ("""weight""",)

              # adding batch stats from flax batch norm to pt
              elif "mean" in flax_key_tuple[-1]:
                     __UpperCAmelCase     				=flax_key_tuple[:-1] + ("""running_mean""",)
              elif "var" in flax_key_tuple[-1]:
                     __UpperCAmelCase     				=flax_key_tuple[:-1] + ("""running_var""",)

              if "batch_stats" in flax_state:
                     __UpperCAmelCase     				=""".""".join(flax_key_tuple[1:]		)  # Remove the params/batch_stats header
              else:
                     __UpperCAmelCase     				=""".""".join(A_		)

              # We also need to look at `pt_model_dict` and see if there are keys requiring further transformation.
              __UpperCAmelCase     				={}
              # New `weight_norm` from https://github.com/huggingface/transformers/pull/24030
              for key in pt_model_dict:
                     __UpperCAmelCase     				=key.split("""."""		)
                     __UpperCAmelCase     				=None
                     if key_components[-3::2] == ["parametrizations", "original0"]:
                            __UpperCAmelCase     				=key_components[-2] + """_g"""
                     elif key_components[-3::2] == ["parametrizations", "original1"]:
                            __UpperCAmelCase     				=key_components[-2] + """_v"""
                     if name is not None:
                            __UpperCAmelCase     				=key_components[:-3] + [name]
                            __UpperCAmelCase     				=""".""".join(A_		)
                            __UpperCAmelCase     				=key

              if flax_key in special_pt_names:
                     __UpperCAmelCase     				=special_pt_names[flax_key]

              if flax_key in pt_model_dict:
                     if flax_tensor.shape != pt_model_dict[flax_key].shape:
                            raise ValueError(
                                F'''Flax checkpoint seems to be incorrect. Weight {flax_key_tuple} was expected '''
                                F'''to be of shape {pt_model_dict[flax_key].shape}, but is {flax_tensor.shape}.'''		)
                     else:
                            # add weight to pytorch dict
                            __UpperCAmelCase     				=np.asarray(A_		) if not isinstance(A_  ,      np.ndarray		) else flax_tensor
                            __UpperCAmelCase     				=torch.from_numpy(A_		)
                            # remove from missing keys
                            missing_keys.remove(A_		)
              else:
                     # weight is not expected by PyTorch model
                     unexpected_keys.append(A_		)

       pt_model.load_state_dict(A_		)

       # re-transform missing_keys to list
       __UpperCAmelCase     				=list(A_		)

       if len(A_		) > 0:
              logger.warning(
                  """Some weights of the Flax model were not used when initializing the PyTorch model"""
                  F''' {pt_model.__class__.__name__}: {unexpected_keys}\n- This IS expected if you are initializing'''
                  F''' {pt_model.__class__.__name__} from a Flax model trained on another task or with another architecture'''
                  """ (e.g. initializing a BertForSequenceClassification model from a FlaxBertForPreTraining model).\n- This"""
                  F''' IS NOT expected if you are initializing {pt_model.__class__.__name__} from a Flax model that you expect'''
                  """ to be exactly identical (e.g. initializing a BertForSequenceClassification model from a"""
                  """ FlaxBertForSequenceClassification model)."""		)
       else:
              logger.warning(F'''All Flax model weights were used when initializing {pt_model.__class__.__name__}.\n'''		)
       if len(A_		) > 0:
              logger.warning(
                  F'''Some weights of {pt_model.__class__.__name__} were not initialized from the Flax model and are newly'''
                  F''' initialized: {missing_keys}\nYou should probably TRAIN this model on a down-stream task to be able to'''
                  """ use it for predictions and inference."""		)
       else:
              logger.warning(
                  F'''All the weights of {pt_model.__class__.__name__} were initialized from the Flax model.\n'''
                  """If your task is similar to the task the model of the checkpoint was trained on, """
                  F'''you can already use {pt_model.__class__.__name__} for predictions without further training.'''		)

       return pt_model










'''simple docstring'''


from math import isqrt, loga
def 						lowerCamelCase__   (				a							):
						__snake_case						 =   [True] * max_number
						for i in range(2    ,	isqrt(max_number - 1							) + 1							):
												if is_prime[i]:
																		for j in range(i**2    ,	a    ,	a							):
																								__snake_case						 =   False

						return [i for i in range(2    ,	a							) if is_prime[i]]
def 						lowerCamelCase__   (				a = 800800    ,	a = 800800							):
						__snake_case						 =   degree * loga(a							)
						__snake_case						 =   int(a							)
						__snake_case						 =   calculate_prime_numbers(a							)

						__snake_case						 =   0
						__snake_case						 =   0
						__snake_case						 =   len(a							) - 1
						while left < right:
												while (
												    prime_numbers[right] * loga(prime_numbers[left]							)
												    + prime_numbers[left] * loga(prime_numbers[right]							)
												    > upper_bound
												):
																		right -= 1
												hybrid_integers_count += right - left
												left += 1

						return hybrid_integers_count


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

