


def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->List[str]:
   UpperCAmelCase      					=  [[] for _ in range(__snake_case )]
   UpperCAmelCase      					=  key - 1

   if key <= 0:
      raise ValueError("""Height of grid can't be 0 or negative""" )
   if key == 1 or len(__snake_case ) <= key:
      return input_string

   for position, character in enumerate(__snake_case ):
      UpperCAmelCase      					=  position % (lowest * 2)  # puts it in bounds
      UpperCAmelCase      					=  min(__snake_case	,    lowest * 2 - num )  # creates zigzag pattern
      temp_grid[num].append(__snake_case )
   UpperCAmelCase      					=  ["""""".join(__snake_case ) for row in temp_grid]
   UpperCAmelCase      					=  """""".join(__snake_case )

   return output_string
def 	_UpperCamelCase					(    lowerCAmelCase_	,    lowerCAmelCase_ )    ->Any:
   UpperCAmelCase      					=  []
   UpperCAmelCase      					=  key - 1

   if key <= 0:
      raise ValueError("""Height of grid can't be 0 or negative""" )
   if key == 1:
      return input_string

   UpperCAmelCase      					=  [[] for _ in range(__snake_case )]  # generates template
   for position in range(len(__snake_case ) ):
      UpperCAmelCase      					=  position % (lowest * 2)  # puts it in bounds
      UpperCAmelCase      					=  min(__snake_case	,    lowest * 2 - num )  # creates zigzag pattern
      temp_grid[num].append("""*""" )

   UpperCAmelCase      					=  0
   for row in temp_grid:  # fills in the characters
      UpperCAmelCase      					=  input_string[counter : counter + len(__snake_case )]
      grid.append(list(__snake_case ) )
      counter += len(__snake_case )

   UpperCAmelCase      					=  """"""  # reads as zigzag
   for position in range(len(__snake_case ) ):
      UpperCAmelCase      					=  position % (lowest * 2)  # puts it in bounds
      UpperCAmelCase      					=  min(__snake_case	,    lowest * 2 - num )  # creates zigzag pattern
      output_string += grid[num][0]
      grid[num].pop(0 )
   return output_string
def 	_UpperCamelCase					(    lowerCAmelCase_ )    ->int:
   UpperCAmelCase      					=  {}
   for key_guess in range(1	,    len(__snake_case ) ):  # tries every key
      UpperCAmelCase      					=  decrypt(__snake_case	,    __snake_case )
   return results


if __name__ == "__main__":
 import doctest

 doctest.testmod()











import re

import jax.numpy as jnp
from flax.traverse_util import flatten_dict, unflatten_dict
from jax.random import PRNGKey

from ..utils import logging


lowerCamelCase      :       int    =						logging.get_logger(__name__)





def    __lowerCAmelCase   (    __snake_case							):
     __lowerCAmelCase             =       r"\w+[.]\d+"
     __lowerCAmelCase             =       re.findall(__snake_case       ,			__snake_case							)
     for pat in pats:
          __lowerCAmelCase             =       key.replace(__snake_case       ,			"_".join(pat.split("."							)							)							)
     return key





def    __lowerCAmelCase   (    __snake_case       ,			__snake_case       ,			__snake_case							):
     __lowerCAmelCase             =       pt_tuple_key[:-1] + ("scale",)
     if (
         any("norm" in str_ for str_ in pt_tuple_key							)
         and (pt_tuple_key[-1] == "bias")
         and (pt_tuple_key[:-1] + ("bias",) not in random_flax_state_dict)
         and (pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict)
     ):
          __lowerCAmelCase             =       pt_tuple_key[:-1] + ("scale",)
          return renamed_pt_tuple_key, pt_tensor
     elif pt_tuple_key[-1] in ["weight", "gamma"] and pt_tuple_key[:-1] + ("scale",) in random_flax_state_dict:
          __lowerCAmelCase             =       pt_tuple_key[:-1] + ("scale",)
          return renamed_pt_tuple_key, pt_tensor

     # embedding
     if pt_tuple_key[-1] == "weight" and pt_tuple_key[:-1] + ("embedding",) in random_flax_state_dict:
          __lowerCAmelCase             =       pt_tuple_key[:-1] + ("embedding",)
          return renamed_pt_tuple_key, pt_tensor

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

     # linear layer
     __lowerCAmelCase             =       pt_tuple_key[:-1] + ("kernel",)
     if pt_tuple_key[-1] == "weight":
          __lowerCAmelCase             =       pt_tensor.T
          return renamed_pt_tuple_key, pt_tensor

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

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

     return pt_tuple_key, pt_tensor





def    __lowerCAmelCase   (    __snake_case       ,			__snake_case       ,			__snake_case=42							):
     # Step 1: Convert pytorch tensor to numpy
     __lowerCAmelCase             =       {k: v.numpy() for k, v in pt_state_dict.items()}

     # Step 2: Since the model is stateless, get random Flax params
     __lowerCAmelCase             =       flax_model.init_weights(PRNGKey(__snake_case							)							)

     __lowerCAmelCase             =       flatten_dict(__snake_case							)
     __lowerCAmelCase             =       {}

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

          # Correctly rename weight parameters
          __lowerCAmelCase      ,			__lowerCAmelCase             =       rename_key_and_reshape_tensor(__snake_case       ,			__snake_case       ,			__snake_case							)

          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}."""							)

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

     return unflatten_dict(__snake_case							)






