





import argparse
import pickle

import numpy as np
import torch
from torch import nn

from transformers import ReformerConfig, ReformerModelWithLMHead
from transformers.utils import logging


logging.set_verbosity_info()





def      lowerCAmelCase_ (       __a	,    __a	,    __a=None		)     ->		Dict:







  """simple docstring"""





  assert torch_layer.weight.shape == weight.shape, F"""{torch_layer} layer.weight does not match"""
  lowerCamelCase__:      List[str]			  =nn.Parameter(__a		)
  if bias is not None:
    assert torch_layer.bias.shape == bias.shape, F"""{torch_layer} layer.bias does not match"""
    lowerCamelCase__:      Optional[Any]			  =nn.Parameter(__a		)





def      lowerCAmelCase_ (       __a	,    __a	,    __a		)     ->		int:







  """simple docstring"""





  lowerCamelCase__:      List[str]			  =np.asarray(weights[0]		)
  lowerCamelCase__:      Any			  =np.asarray(weights[1]		)
  lowerCamelCase__:      str			  =np.asarray(weights[2]		)

  set_param(
      torch_layer.self_attention.query_key	,    torch.tensor(__a		).transpose(1	,    2		).contiguous().view(-1	,    __a		)	,    )
  set_param(
      torch_layer.self_attention.value	,    torch.tensor(__a		).transpose(1	,    2		).contiguous().view(-1	,    __a		)	,    )
  set_param(
      torch_layer.output.dense	,    torch.tensor(__a		).view(-1	,    __a		).contiguous().transpose(0	,    1		)	,    )





def      lowerCAmelCase_ (       __a	,    __a	,    __a		)     ->		List[str]:







  """simple docstring"""





  lowerCamelCase__:      Any			  =np.asarray(weights[0]		)
  lowerCamelCase__:      List[str]			  =np.asarray(weights[1]		)
  lowerCamelCase__:      Tuple			  =np.asarray(weights[2]		)
  lowerCamelCase__:      Optional[int]			  =np.asarray(weights[3]		)

  set_param(
      torch_layer.self_attention.query	,    torch.tensor(__a		).transpose(1	,    2		).contiguous().view(-1	,    __a		)	,    )
  set_param(
      torch_layer.self_attention.key	,    torch.tensor(__a		).transpose(1	,    2		).contiguous().view(-1	,    __a		)	,    )
  set_param(
      torch_layer.self_attention.value	,    torch.tensor(__a		).transpose(1	,    2		).contiguous().view(-1	,    __a		)	,    )
  set_param(
      torch_layer.output.dense	,    torch.tensor(__a		).view(-1	,    __a		).contiguous().transpose(0	,    1		)	,    )





def      lowerCAmelCase_ (       __a	,    __a	,    __a		)     ->		Union[str, Any]:







  """simple docstring"""





  lowerCamelCase__:      Union[str, Any]			  =weights[0][0][0]
  lowerCamelCase__:      Tuple			  =np.asarray(layer_norm_a[0]		)
  lowerCamelCase__:      str			  =np.asarray(layer_norm_a[1]		)
  set_param(
      torch_block.attention.layer_norm	,    torch.tensor(__a		)	,    torch.tensor(__a		)	,    )

  # lsh weights + output
  lowerCamelCase__:      List[Any]			  =weights[0][1]
  if len(__a		) < 4:
    set_layer_weights_in_torch_lsh(__a	,    torch_block.attention	,    __a		)
  else:
    set_layer_weights_in_torch_local(__a	,    torch_block.attention	,    __a		)

  # intermediate weighs
  lowerCamelCase__:      List[Any]			  =weights[2][0][1][2]

  # Chunked Feed Forward
  if len(__a		) == 4:
    lowerCamelCase__:      List[Any]			  =intermediate_weights[2]

  # layernorm 2
  lowerCamelCase__:      int			  =np.asarray(intermediate_weights[0][0]		)
  lowerCamelCase__:      Tuple			  =np.asarray(intermediate_weights[0][1]		)
  set_param(
      torch_block.feed_forward.layer_norm	,    torch.tensor(__a		)	,    torch.tensor(__a		)	,    )

  # intermediate dense
  lowerCamelCase__:      Optional[Any]			  =np.asarray(intermediate_weights[1][0]		)
  lowerCamelCase__:      str			  =np.asarray(intermediate_weights[1][1]		)
  set_param(
      torch_block.feed_forward.dense.dense	,    torch.tensor(__a		).transpose(0	,    1		).contiguous()	,    torch.tensor(__a		)	,    )

  # intermediate out
  lowerCamelCase__:      List[Any]			  =np.asarray(intermediate_weights[4][0]		)
  lowerCamelCase__:      Optional[Any]			  =np.asarray(intermediate_weights[4][1]		)
  set_param(
      torch_block.feed_forward.output.dense	,    torch.tensor(__a		).transpose(0	,    1		).contiguous()	,    torch.tensor(__a		)	,    )





def      lowerCAmelCase_ (       __a	,    __a	,    __a		)     ->		Tuple:







  """simple docstring"""





  lowerCamelCase__:      str			  =torch_model.reformer

  # word embeds
  lowerCamelCase__:      Optional[Any]			  =np.asarray(weights[1]		)
  set_param(
      torch_model_reformer.embeddings.word_embeddings	,    torch.tensor(__a		)	,    )

  if isinstance(weights[3]	,    __a		):
    lowerCamelCase__:      Any			  =torch_model_reformer.embeddings.position_embeddings
    for emb_idx in range(len(position_embeddings.weights		)		):
      lowerCamelCase__:      Any			  =np.asarray(weights[3][emb_idx][0]		)
      assert (
          position_embeddings.weights[emb_idx].shape == emb_weights.shape
      ), F"""{position_embeddings[emb_idx]} emb does not match"""
      lowerCamelCase__:      Any			  =nn.Parameter(torch.tensor(__a		)		)

  lowerCamelCase__:      List[str]			  =weights[5]
  assert len(torch_model_reformer.encoder.layers		) * 4 == len(
      __a		), "HF and trax model do not have the same number of layers"
  for layer_idx, layer in enumerate(torch_model_reformer.encoder.layers		):
    lowerCamelCase__:      str			  =trax_layer_weights[4 * layer_idx : 4 * (layer_idx + 1)]
    set_block_weights_in_torch(__a	,    __a	,    __a		)

  # output layer norm
  lowerCamelCase__:      Any			  =np.asarray(weights[7][0]		)
  lowerCamelCase__:      str			  =np.asarray(weights[7][1]		)
  set_param(
      torch_model_reformer.encoder.layer_norm	,    torch.tensor(__a		)	,    torch.tensor(__a		)	,    )

  # output embeddings
  lowerCamelCase__:      List[str]			  =np.asarray(weights[9][0]		)
  lowerCamelCase__:      Dict			  =np.asarray(weights[9][1]		)
  set_param(
      torch_model.lm_head.decoder	,    torch.tensor(__a		).transpose(0	,    1		).contiguous()	,    torch.tensor(__a		)	,    )





def      lowerCAmelCase_ (       __a	,    __a	,    __a		)     ->		str:







  """simple docstring"""





  lowerCamelCase__:      int			  =ReformerConfig.from_json_file(__a		)
  print(F"""Building PyTorch model from configuration: {config}"""		)
  lowerCamelCase__:      List[Any]			  =ReformerModelWithLMHead(__a		)

  with open(__a	,    "rb"		) as f:
    lowerCamelCase__:      List[str]			  =pickle.load(__a		)["""weights"""]

  set_model_weights_in_torch(__a	,    __a	,    config.hidden_size		)

  # Save pytorch-model
  print(F"""Save PyTorch model to {pytorch_dump_path}"""		)
  torch.save(model.state_dict()	,    __a		)


if __name__ == "__main__":
     __A									=				argparse.ArgumentParser()
     # Required parameters
     parser.add_argument(
         "--trax_model_pkl_path", default=None, type=str, required=True, help="Path to the TensorFlow checkpoint path."
     )
     parser.add_argument(
         "--config_file",
         default=None,
         type=str,
         required=True,
         help=(
             "The config json file corresponding to the pre-trained Reformer model. \n"
             "This specifies the model architecture."
         ),
     )
     parser.add_argument(
         "--pytorch_dump_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
     )
     __A									=				parser.parse_args()
     convert_trax_checkpoint_to_pytorch(args.trax_model_pkl_path, args.config_file, args.pytorch_dump_path)






"""simple docstring"""
from collections import defaultdict
from math import ceil, sqrt

def       _snake_case						(						UpperCamelCase						:		int = 1000000			,		UpperCamelCase						:		int = 10						):
 UpperCAmelCase	:					defaultdict	=	defaultdict(UpperCamelCase						)

 for outer_width in range(3			,		(t_limit // 4) + 2						):
  if outer_width * outer_width > t_limit:
   UpperCAmelCase	:					str	=	max(
       ceil(sqrt(outer_width * outer_width - t_limit						)						)			,		1						)
  else:
   UpperCAmelCase	:					Optional[Any]	=	1

  hole_width_lower_bound += (outer_width - hole_width_lower_bound) % 2

  for hole_width in range(UpperCamelCase			,		outer_width - 1			,		2						):
   count[outer_width * outer_width - hole_width * hole_width] += 1

 return sum(1 for n in count.values() if 1 <= n <= 10						)


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