






"""simple docstring"""



import tempfile
import unittest

import numpy as np

import transformers
from transformers import GPTaConfig, GPTaTokenizer, is_flax_available, is_torch_available
from transformers.testing_utils import is_pt_flax_cross_test, require_flax, slow

from ...generation.test_flax_utils import FlaxGenerationTesterMixin
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask


if is_flax_available():
    import jax
    import jax.numpy as jnp

    from transformers.modeling_flax_pytorch_utils import (
        convert_pytorch_state_dict_to_flax,
        load_flax_weights_in_pytorch_model,
    )
    from transformers.models.gpta.modeling_flax_gpta import FlaxGPTaLMHeadModel, FlaxGPTaModel

if is_torch_available():
    import torch

class 	a					:







    def __init__(      self							,		_lowerCamelCase							,		_lowerCamelCase=1_4							,		_lowerCamelCase=7							,		_lowerCamelCase=True							,		_lowerCamelCase=True							,		_lowerCamelCase=False							,		_lowerCamelCase=True							,		_lowerCamelCase=9_9							,		_lowerCamelCase=3_2							,		_lowerCamelCase=5							,		_lowerCamelCase=4							,		_lowerCamelCase=3_7							,		_lowerCamelCase="gelu"							,		_lowerCamelCase=0.1							,		_lowerCamelCase=0.1							,		_lowerCamelCase=5_1_2							,		_lowerCamelCase=0.0_2							,		):
      lowercase							   =	parent
      lowercase							   =	batch_size
      lowercase							   =	seq_length
      lowercase							   =	is_training
      lowercase							   =	use_input_mask
      lowercase							   =	use_token_type_ids
      lowercase							   =	use_labels
      lowercase							   =	vocab_size
      lowercase							   =	hidden_size
      lowercase							   =	num_hidden_layers
      lowercase							   =	num_attention_heads
      lowercase							   =	intermediate_size
      lowercase							   =	hidden_act
      lowercase							   =	hidden_dropout_prob
      lowercase							   =	attention_probs_dropout_prob
      lowercase							   =	max_position_embeddings
      lowercase							   =	initializer_range
      lowercase							   =	None
      lowercase							   =	vocab_size - 1
      lowercase							   =	vocab_size - 1
      lowercase							   =	vocab_size - 1







    def       UpperCamelCase_				(      self	):
      lowercase							   =	ids_tensor([self.batch_size, self.seq_length]							,		self.vocab_size	)

      lowercase							   =	None
      if self.use_input_mask:
        lowercase							   =	random_attention_mask([self.batch_size, self.seq_length]	)

      lowercase							   =	GPTaConfig(
          vocab_size=self.vocab_size							,		n_embd=self.hidden_size							,		n_layer=self.num_hidden_layers							,		n_head=self.num_attention_heads							,		n_positions=self.max_position_embeddings							,		use_cache=_lowerCamelCase							,		bos_token_id=self.bos_token_id							,		eos_token_id=self.eos_token_id							,		pad_token_id=self.pad_token_id							,		)

      return (config, input_ids, input_mask)







    def       UpperCamelCase_				(      self	):
      lowercase							   =	self.prepare_config_and_inputs()
      lowercase   ,					lowercase   ,					lowercase							   =	config_and_inputs
      lowercase							   =	{'input_ids': input_ids, 'attention_mask': attention_mask}
      return config, inputs_dict







    def       UpperCamelCase_				(      self	):
      lowercase   ,					lowercase   ,					lowercase							   =	self.prepare_config_and_inputs()

      lowercase							   =	floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
      lowercase							   =	ids_tensor([self.batch_size, self.seq_length]							,		vocab_size=2	)

      return (
          config,
          input_ids,
          attention_mask,
          encoder_hidden_states,
          encoder_attention_mask,
      )







    def       UpperCamelCase_				(      self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase	):
      lowercase							   =	2_0
      lowercase							   =	model_class_name(_lowerCamelCase	)

      lowercase							   =	model.init_cache(input_ids.shape[0]							,		_lowerCamelCase	)
      lowercase							   =	jnp.ones((input_ids.shape[0], max_decoder_length)							,		dtype='i4'	)

      lowercase							   =	jnp.broadcast_to(
          jnp.arange(input_ids.shape[-1] - 1	)[None, :]							,		(input_ids.shape[0], input_ids.shape[-1] - 1)	)
      lowercase							   =	model(
          input_ids[:, :-1]							,		attention_mask=_lowerCamelCase							,		past_key_values=_lowerCamelCase							,		position_ids=_lowerCamelCase							,		)

      lowercase							   =	jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]							,		dtype='i4'	)
      lowercase							   =	model(
          input_ids[:, -1:]							,		attention_mask=_lowerCamelCase							,		past_key_values=outputs_cache.past_key_values							,		position_ids=_lowerCamelCase							,		)

      lowercase							   =	model(_lowerCamelCase	)

      lowercase							   =	np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
      self.parent.assertTrue(diff < 1e-3							,		msg=F'Max diff is {diff}'	)







    def       UpperCamelCase_				(      self							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase	):
      lowercase							   =	2_0
      lowercase							   =	model_class_name(_lowerCamelCase	)

      lowercase							   =	jnp.concatenate(
          [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])	)]							,		axis=-1							,		)

      lowercase							   =	model.init_cache(input_ids.shape[0]							,		_lowerCamelCase	)
      lowercase							   =	jnp.broadcast_to(
          jnp.arange(input_ids.shape[-1] - 1	)[None, :]							,		(input_ids.shape[0], input_ids.shape[-1] - 1)	)

      lowercase							   =	model(
          input_ids[:, :-1]							,		attention_mask=_lowerCamelCase							,		past_key_values=_lowerCamelCase							,		position_ids=_lowerCamelCase							,		)
      lowercase							   =	jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]							,		dtype='i4'	)
      lowercase							   =	model(
          input_ids[:, -1:]							,		past_key_values=outputs_cache.past_key_values							,		attention_mask=_lowerCamelCase							,		position_ids=_lowerCamelCase							,		)

      lowercase							   =	model(_lowerCamelCase							,		attention_mask=_lowerCamelCase	)

      lowercase							   =	np.max(np.abs((outputs_cache_next[0][:, -1, :5] - outputs[0][:, -1, :5])	)	)
      self.parent.assertTrue(diff < 1e-3							,		msg=F'Max diff is {diff}'	)


@require_flax
class 	a					(       a_,    a_,    unittest.TestCase     ):
    UpperCAmelCase_			:					Dict     					=(FlaxGPTaModel, FlaxGPTaLMHeadModel) if is_flax_available() else ()
    UpperCAmelCase_			:					Tuple     					=(FlaxGPTaLMHeadModel,) if is_flax_available() else ()







    def       UpperCamelCase_				(      self	):
      lowercase							   =	FlaxGPTaModelTester(self	)







    def       UpperCamelCase_				(      self	):
      for model_class_name in self.all_model_classes:
        lowercase   ,					lowercase   ,					lowercase							   =	self.model_tester.prepare_config_and_inputs()
        self.model_tester.check_use_cache_forward(_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase	)







    def       UpperCamelCase_				(      self	):
      for model_class_name in self.all_model_classes:
        lowercase   ,					lowercase   ,					lowercase							   =	self.model_tester.prepare_config_and_inputs()
        self.model_tester.check_use_cache_forward_with_attn_mask(
            _lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase							,		_lowerCamelCase	)







    @slow
    def       UpperCamelCase_				(      self	):
      lowercase							   =	GPTaTokenizer.from_pretrained('gpt2'							,		pad_token='</s>'							,		padding_side='left'	)
      lowercase							   =	tokenizer(['Hello this is a long string', 'Hey']							,		return_tensors='np'							,		padding=_lowerCamelCase							,		truncation=_lowerCamelCase	)

      lowercase							   =	FlaxGPTaLMHeadModel.from_pretrained('gpt2'	)
      lowercase							   =	False
      lowercase							   =	model.config.eos_token_id

      lowercase							   =	jax.jit(model.generate	)

      lowercase							   =	jit_generate(inputs['input_ids']							,		attention_mask=inputs['attention_mask']	).sequences

      lowercase							   =	tokenizer.batch_decode(_lowerCamelCase							,		skip_special_tokens=_lowerCamelCase	)

      lowercase							   =	[
          'Hello this is a long string of words. I\'m going to start with the first one.\n',
          'Hey, I\'m not sure if I\'m going to be able to do',
      ]

      self.assertListEqual(_lowerCamelCase							,		_lowerCamelCase	)







    @is_pt_flax_cross_test
    def       UpperCamelCase_				(      self	):
      lowercase   ,					lowercase							   =	self.model_tester.prepare_config_and_inputs_for_common()

      for model_class in self.all_model_classes:
        with self.subTest(model_class.__name__	):
          # prepare inputs
          lowercase							   =	self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase	)
          lowercase							   =	{k: torch.tensor(v.tolist()	) for k, v in prepared_inputs_dict.items()}

          # load corresponding PyTorch class
          lowercase							   =	model_class.__name__[4:]  # Skip the "Flax" at the beginning
          lowercase							   =	getattr(_lowerCamelCase							,		_lowerCamelCase	)

          lowercase   ,					lowercase							   =	pt_inputs['input_ids'].shape
          lowercase							   =	np.random.randint(0							,		seq_length - 1							,		size=(batch_size,)	)
          for batch_idx, start_index in enumerate(_lowerCamelCase	):
            lowercase							   =	0
            lowercase							   =	1
            lowercase							   =	0
            lowercase							   =	1
          lowercase							   =	pt_model_class(_lowerCamelCase	).eval()
          lowercase							   =	model_class(_lowerCamelCase							,		dtype=jnp.floataa	)

          lowercase							   =	convert_pytorch_state_dict_to_flax(pt_model.state_dict()							,		_lowerCamelCase	)
          lowercase							   =	fx_state

          with torch.no_grad():
            lowercase							   =	pt_model(**_lowerCamelCase	).to_tuple()

          lowercase							   =	fx_model(**_lowerCamelCase	).to_tuple()
          self.assertEqual(len(_lowerCamelCase	)							,		len(_lowerCamelCase	)							,		'Output lengths differ between Flax and PyTorch'	)
          for fx_output, pt_output in zip(_lowerCamelCase							,		_lowerCamelCase	):
            self.assert_almost_equals(fx_output[:, -1]							,		pt_output[:, -1].numpy()							,		4e-2	)

          with tempfile.TemporaryDirectory() as tmpdirname:
            pt_model.save_pretrained(_lowerCamelCase	)
            lowercase							   =	model_class.from_pretrained(_lowerCamelCase							,		from_pt=_lowerCamelCase	)

          lowercase							   =	fx_model_loaded(**_lowerCamelCase	).to_tuple()
          self.assertEqual(
              len(_lowerCamelCase	)							,		len(_lowerCamelCase	)							,		'Output lengths differ between Flax and PyTorch'	)
          for fx_output_loaded, pt_output in zip(_lowerCamelCase							,		_lowerCamelCase	):
            self.assert_almost_equals(fx_output_loaded[:, -1]							,		pt_output[:, -1].numpy()							,		4e-2	)







    @is_pt_flax_cross_test
    def       UpperCamelCase_				(      self	):
      lowercase   ,					lowercase							   =	self.model_tester.prepare_config_and_inputs_for_common()
      for model_class in self.all_model_classes:
        with self.subTest(model_class.__name__	):
          # prepare inputs
          lowercase							   =	self._prepare_for_class(_lowerCamelCase							,		_lowerCamelCase	)
          lowercase							   =	{k: torch.tensor(v.tolist()	) for k, v in prepared_inputs_dict.items()}

          # load corresponding PyTorch class
          lowercase							   =	model_class.__name__[4:]  # Skip the "Flax" at the beginning
          lowercase							   =	getattr(_lowerCamelCase							,		_lowerCamelCase	)

          lowercase							   =	pt_model_class(_lowerCamelCase	).eval()
          lowercase							   =	model_class(_lowerCamelCase							,		dtype=jnp.floataa	)

          lowercase							   =	load_flax_weights_in_pytorch_model(_lowerCamelCase							,		fx_model.params	)
          lowercase   ,					lowercase							   =	pt_inputs['input_ids'].shape
          lowercase							   =	np.random.randint(0							,		seq_length - 1							,		size=(batch_size,)	)
          for batch_idx, start_index in enumerate(_lowerCamelCase	):
            lowercase							   =	0
            lowercase							   =	1
            lowercase							   =	0
            lowercase							   =	1

          # make sure weights are tied in PyTorch
          pt_model.tie_weights()

          with torch.no_grad():
            lowercase							   =	pt_model(**_lowerCamelCase	).to_tuple()

          lowercase							   =	fx_model(**_lowerCamelCase	).to_tuple()
          self.assertEqual(len(_lowerCamelCase	)							,		len(_lowerCamelCase	)							,		'Output lengths differ between Flax and PyTorch'	)
          for fx_output, pt_output in zip(_lowerCamelCase							,		_lowerCamelCase	):
            self.assert_almost_equals(fx_output[:, -1]							,		pt_output[:, -1].numpy()							,		4e-2	)

          with tempfile.TemporaryDirectory() as tmpdirname:
            fx_model.save_pretrained(_lowerCamelCase	)
            lowercase							   =	pt_model_class.from_pretrained(_lowerCamelCase							,		from_flax=_lowerCamelCase	)

          with torch.no_grad():
            lowercase							   =	pt_model_loaded(**_lowerCamelCase	).to_tuple()

          self.assertEqual(
              len(_lowerCamelCase	)							,		len(_lowerCamelCase	)							,		'Output lengths differ between Flax and PyTorch'	)
          for fx_output, pt_output in zip(_lowerCamelCase							,		_lowerCamelCase	):
            self.assert_almost_equals(fx_output[:, -1]							,		pt_output[:, -1].numpy()							,		4e-2	)







    @slow
    def       UpperCamelCase_				(      self	):
      for model_class_name in self.all_model_classes:
        lowercase							   =	model_class_name.from_pretrained('gpt2'							,		from_pt=_lowerCamelCase	)
        lowercase							   =	model(np.ones((1, 1)	)	)
        self.assertIsNotNone(_lowerCamelCase	)










"""simple docstring"""



_UpperCamelCase		:  str						=		1_0**8
def 						_SCREAMING_SNAKE_CASE			(   __snake_case      :  int   ):





  '''simple docstring'''





  if n % 10 == 0:
    return False
  lowercase							   =	str(__snake_case   )
  return s == s[::-1]
def 						_SCREAMING_SNAKE_CASE			(   ):





  '''simple docstring'''





  lowercase							   =	set()
  lowercase							   =	1
  lowercase							   =	5
  while sum_squares < LIMIT:
    lowercase							   =	first_square + 1
    while sum_squares < LIMIT:
      if is_palindrome(__snake_case   ):
        answer.add(__snake_case   )
      last_square += 1
      sum_squares += last_square**2
    first_square += 1
    lowercase							   =	first_square**2 + (first_square + 1) ** 2

  return sum(__snake_case   )


if __name__ == "__main__":
    print(solution())


