




from pickle import UnpicklingError

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

from ..utils import logging


__a          =			logging.get_logger(__name__)







def lowerCamelCase__       (      _lowercase			,						_lowercase				):

     '''simple docstring'''


     try:
          with open(_lowercase			,						'''rb'''				) as flax_state_f:
               UpperCAmelCase_      :							List[Any]       =      from_bytes(_lowercase			,						flax_state_f.read()				)
     except UnpicklingError as e:
          try:
               with open(_lowercase				) as f:
                    if f.read().startswith('''version'''				):
                         raise OSError(
                             '''You seem to have cloned a repository without having git-lfs installed. Please'''
                             ''' install git-lfs and run `git lfs install` followed by `git lfs pull` in the'''
                             ''' folder you cloned.'''				)
                    else:
                         raise ValueError from e
          except (UnicodeDecodeError, ValueError):
               raise EnvironmentError(f'''Unable to convert {model_file} to Flax deserializable object. '''				)

     return load_flax_weights_in_pytorch_model(_lowercase			,						_lowercase				)







def lowerCamelCase__       (      _lowercase			,						_lowercase				):

     '''simple docstring'''


     try:
          import torch  # noqa: F401
     except ImportError:
          logger.error(
              '''Loading 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_      :							Optional[Any]       =      flatten_dict(jax.tree_util.tree_map(lambda _lowercase				: x.dtype == jnp.bfloataa			,						_lowercase				)				).values()
     if any(_lowercase				):
          # convert all weights to fp32 if they 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_      :							int       =      jax.tree_util.tree_map(
              lambda _lowercase				: params.astype(np.floataa				) if params.dtype == jnp.bfloataa else params			,						_lowercase				)

     UpperCAmelCase_      :							Tuple       =      ''''''

     UpperCAmelCase_      :							Optional[int]       =      flatten_dict(_lowercase			,						sep='''.'''				)
     UpperCAmelCase_      :							Union[str, Any]       =      pt_model.state_dict()

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

     for flax_key_tuple, flax_tensor in flax_state_dict.items():
          UpperCAmelCase_      :							List[str]       =      flax_key_tuple.split('''.'''				)

          if flax_key_tuple_array[-1] == "kernel" and flax_tensor.ndim == 4:
               UpperCAmelCase_      :							Dict       =      flax_key_tuple_array[:-1] + ['''weight''']
               UpperCAmelCase_      :							str       =      jnp.transpose(_lowercase			,						(3, 2, 0, 1)				)
          elif flax_key_tuple_array[-1] == "kernel":
               UpperCAmelCase_      :							Optional[int]       =      flax_key_tuple_array[:-1] + ['''weight''']
               UpperCAmelCase_      :							List[Any]       =      flax_tensor.T
          elif flax_key_tuple_array[-1] == "scale":
               UpperCAmelCase_      :							Any       =      flax_key_tuple_array[:-1] + ['''weight''']

          if "time_embedding" not in flax_key_tuple_array:
               for i, flax_key_tuple_string in enumerate(_lowercase				):
                    UpperCAmelCase_      :							Optional[Any]       =      (
                        flax_key_tuple_string.replace('''_0'''			,						'''.0'''				)
                        .replace('''_1'''			,						'''.1'''				)
                        .replace('''_2'''			,						'''.2'''				)
                        .replace('''_3'''			,						'''.3'''				)
                        .replace('''_4'''			,						'''.4'''				)
                        .replace('''_5'''			,						'''.5'''				)
                        .replace('''_6'''			,						'''.6'''				)
                        .replace('''_7'''			,						'''.7'''				)
                        .replace('''_8'''			,						'''.8'''				)
                        .replace('''_9'''			,						'''.9'''				)
                    )

          UpperCAmelCase_      :							str       =      '''.'''.join(_lowercase				)

          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_      :							int       =      np.asarray(_lowercase				) if not isinstance(_lowercase			,						np.ndarray				) else flax_tensor
                    UpperCAmelCase_      :							Any       =      torch.from_numpy(_lowercase				)
                    # remove from missing keys
                    missing_keys.remove(_lowercase				)
          else:
               # weight is not expected by PyTorch model
               unexpected_keys.append(_lowercase				)

     pt_model.load_state_dict(_lowercase				)

     # re-transform missing_keys to list
     UpperCAmelCase_      :							str       =      list(_lowercase				)

     if len(_lowercase				) > 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).'''				)
     if len(_lowercase				) > 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.'''				)

     return pt_model





from math import ceil







def lowerCamelCase__       (      _lowercase = 1001				):

     '''simple docstring'''


     UpperCAmelCase_      :							Optional[Any]       =      1

     for i in range(1			,						int(ceil(n / 2.0				)				)				):
          UpperCAmelCase_      :							List[Any]       =      2 * i + 1
          UpperCAmelCase_      :							Optional[int]       =      2 * i
          UpperCAmelCase_      :							Any       =      total + 4 * odd**2 - 6 * even

     return total


if __name__ == "__main__":
     import sys

     if len(sys.argv) == 1:
          print(solution())
     else:
          try:
               __a          =			int(sys.argv[1])
               print(solution(n))
          except ValueError:
               print('Invalid entry - please enter a number')