


'''simple docstring'''







import unittest
from unittest.util import safe_repr

from transformers import AutoTokenizer, RwkvConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      RWKV_PRETRAINED_MODEL_ARCHIVE_LIST,
      RwkvForCausalLM,
      RwkvModel,
  )
  from transformers.pytorch_utils import is_torch_greater_or_equal_than_2_0
else:
  a__  : int				=	False
class  lowercase_					:


    def __init__(					self  , a  , a=14  , a=7  , a=True  , a=False  , a=True  , a=True  , a=True  , a=99  , a=32  , a=5  , a=37  , a="gelu"  , a=0.1  , a=0.1  , a=5_12  , a=16  , a=2  , a=3  , a=4  , a=None  , ):
          UpperCamelCase__  =    parent
          UpperCamelCase__  =    batch_size
          UpperCamelCase__  =    seq_length
          UpperCamelCase__  =    is_training
          UpperCamelCase__  =    use_token_type_ids
          UpperCamelCase__  =    use_input_mask
          UpperCamelCase__  =    use_labels
          UpperCamelCase__  =    use_mc_token_ids
          UpperCamelCase__  =    vocab_size
          UpperCamelCase__  =    hidden_size
          UpperCamelCase__  =    num_hidden_layers
          UpperCamelCase__  =    intermediate_size
          UpperCamelCase__  =    hidden_act
          UpperCamelCase__  =    hidden_dropout_prob
          UpperCamelCase__  =    attention_probs_dropout_prob
          UpperCamelCase__  =    max_position_embeddings
          UpperCamelCase__  =    type_vocab_size
          UpperCamelCase__  =    type_sequence_label_size
          UpperCamelCase__  =    num_labels
          UpperCamelCase__  =    num_choices
          UpperCamelCase__  =    scope
          UpperCamelCase__  =    vocab_size - 1
          UpperCamelCase__  =    vocab_size - 1
          UpperCamelCase__  =    vocab_size - 1


    def        __a							(					self   ):
          return RwkvConfig.from_pretrained("sgugger/rwkv-4-pile-7b"   )


    def        __a							(					self  , a=False  , a=False  , a=False   ):
          UpperCamelCase__  =    ids_tensor([self.batch_size, self.seq_length]  , self.vocab_size   )

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

          UpperCamelCase__  =    None
          if self.use_token_type_ids:
                UpperCamelCase__  =    ids_tensor([self.batch_size, self.seq_length]  , self.type_vocab_size   )

          UpperCamelCase__  =    None
          if self.use_mc_token_ids:
                UpperCamelCase__  =    ids_tensor([self.batch_size, self.num_choices]  , self.seq_length   )

          UpperCamelCase__  =    None
          UpperCamelCase__  =    None
          UpperCamelCase__  =    None
          if self.use_labels:
                UpperCamelCase__  =    ids_tensor([self.batch_size]  , self.type_sequence_label_size   )
                UpperCamelCase__  =    ids_tensor([self.batch_size, self.seq_length]  , self.num_labels   )
                UpperCamelCase__  =    ids_tensor([self.batch_size]  , self.num_choices   )

          UpperCamelCase__  =    self.get_config(
              gradient_checkpointing=a  , scale_attn_by_inverse_layer_idx=a  , reorder_and_upcast_attn=a  , )

          return (
              config,
              input_ids,
              input_mask,
              None,
              token_type_ids,
              mc_token_ids,
              sequence_labels,
              token_labels,
              choice_labels,
          )


    def        __a							(					self  , a=False  , a=False  , a=False   ):
          return RwkvConfig(
              vocab_size=self.vocab_size  , hidden_size=self.hidden_size  , num_hidden_layers=self.num_hidden_layers  , intermediate_size=self.intermediate_size  , activation_function=self.hidden_act  , resid_pdrop=self.hidden_dropout_prob  , attn_pdrop=self.attention_probs_dropout_prob  , n_positions=self.max_position_embeddings  , type_vocab_size=self.type_vocab_size  , use_cache=a  , bos_token_id=self.bos_token_id  , eos_token_id=self.eos_token_id  , pad_token_id=self.pad_token_id  , gradient_checkpointing=a  , scale_attn_by_inverse_layer_idx=a  , reorder_and_upcast_attn=a  , )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.get_config()
          UpperCamelCase__  =    3_00
          return config


    def        __a							(					self   ):
          (
              (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     
          )  =    self.prepare_config_and_inputs()

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

          return (
              config,
              input_ids,
              input_mask,
              head_mask,
              token_type_ids,
              sequence_labels,
              token_labels,
              choice_labels,
              encoder_hidden_states,
              encoder_attention_mask,
          )


    def        __a							(					self  , a  , a  , a  , a  , a  , *a   ):
          UpperCamelCase__  =    True
          UpperCamelCase__  =    RwkvModel(config=a   )
          model.to(a   )
          model.eval()

          UpperCamelCase__  =    model(a   )

          self.parent.assertEqual(result.last_hidden_state.shape  , (self.batch_size, self.seq_length, self.hidden_size)   )
          self.parent.assertEqual(len(result.hidden_states   )  , config.num_hidden_layers + 1   )


    def        __a							(					self  , a  , a  , a  , a  , a  , *a   ):
          UpperCamelCase__  =    RwkvForCausalLM(a   )
          model.to(a   )
          model.eval()

          UpperCamelCase__  =    model(a  , labels=a   )
          self.parent.assertEqual(result.loss.shape  , ()   )
          self.parent.assertEqual(result.logits.shape  , (self.batch_size, self.seq_length, self.vocab_size)   )


    def        __a							(					self  , a  , a  , a  , a  , a  , *a   ):
          UpperCamelCase__  =    RwkvModel(config=a   )
          model.to(a   )
          model.eval()

          UpperCamelCase__  =    model(a   )
          UpperCamelCase__  =    outputs.last_hidden_state

          UpperCamelCase__  =    model(input_ids[:, :2]   )
          UpperCamelCase__  =    outputs.last_hidden_state

          # Using the state computed on the first inputs, we will get the same output
          UpperCamelCase__  =    model(input_ids[:, 2:]  , state=outputs.state   )
          UpperCamelCase__  =    outputs.last_hidden_state

          self.parent.assertTrue(torch.allclose(torch.cat([output_one, output_two]  , dim=1   )  , a  , atol=1e-5   )   )


    def        __a							(					self  , a  , a  , a  , a  , a  , *a  , a=False   ):
          UpperCamelCase__  =    RwkvForCausalLM(a   )
          model.to(a   )
          if gradient_checkpointing:
                model.gradient_checkpointing_enable()

          UpperCamelCase__  =    model(a  , labels=a   )
          self.parent.assertEqual(result.loss.shape  , ()   )
          self.parent.assertEqual(result.logits.shape  , (self.batch_size, self.seq_length, self.vocab_size)   )
          result.loss.backward()


    def        __a							(					self   ):
          UpperCamelCase__  =    self.prepare_config_and_inputs()

          (
              (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     (
              UpperCamelCase__
          ) ,     
          )  =    config_and_inputs

          UpperCamelCase__  =    {"input_ids": input_ids}

          return config, inputs_dict

@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0  ,						reason='See https://github.com/huggingface/transformers/pull/24204'       )
@require_torch
class  lowercase_					(   a__  ,						a__  ,						a__  ,						unittest.TestCase       ):
    __UpperCAmelCase             =     (RwkvModel, RwkvForCausalLM) if is_torch_available() else ()
    __UpperCAmelCase             =     (
        {'feature-extraction': RwkvModel, 'text-generation': RwkvForCausalLM} if is_torch_available() else {}
    )
    # all_generative_model_classes = (RwkvForCausalLM,) if is_torch_available() else ()
    __UpperCAmelCase             =     False
    __UpperCAmelCase             =     False
    __UpperCAmelCase             =     False
    __UpperCAmelCase             =     False
    __UpperCAmelCase             =     False  # Rwkv does not support head masking


    def        __a							(					self   ):
          UpperCamelCase__  =    RwkvModelTester(self   )
          UpperCamelCase__  =    ConfigTester(
              self  , config_class=a  , n_embd=37  , common_properties=["hidden_size", "num_hidden_layers"]   )


    def        __a							(					self  , a  , a  , a=None   ):
          if isinstance(a  , torch.Tensor   ):
                UpperCamelCase__ ,     UpperCamelCase__  =    member.max().item(), member.min().item()
          elif isinstance(a  , a   ) or isinstance(a  , a   ):
                UpperCamelCase__ ,     UpperCamelCase__  =    max(a   ), min(a   )

          if not isinstance(a  , a   ):
                raise TypeError("container should be a list or tuple"   )
          elif len(a   ) != 2:
                raise ValueError("container should have 2 elements"   )

          UpperCamelCase__ ,     UpperCamelCase__  =    container

          UpperCamelCase__  =    (min_value >= expected_min) and (max_value <= expected_max)

          if not is_inside_interval:
                UpperCamelCase__  =    "%s not found in %s" % (safe_repr(a   ), safe_repr(a   ))
                self.fail(self._formatMessage(a  , a   )   )


    def        __a							(					self   ):
          self.config_tester.run_common_tests()


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_rwkv_model(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_causl_lm(*a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_state_equivalency(*a   )


    def        __a							(					self   ):
          UpperCamelCase__ ,     UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
                UpperCamelCase__  =    model_class(config=a   )
                for name, param in model.named_parameters():
                      if "time_decay" in name:
                            if param.requires_grad:
                                  self.assertTrue(param.data.max().item() == 3.0   )
                                  self.assertTrue(param.data.min().item() == -5.0   )
                      elif "time_first" in name:
                            if param.requires_grad:
                                  # check if it's a ones like
                                  self.assertTrue(torch.allclose(param.data  , torch.ones_like(param.data   )  , atol=1e-5  , rtol=1e-5   )   )
                      elif any(x in name for x in ["time_mix_key", "time_mix_receptance"]   ):
                            if param.requires_grad:
                                  self.assertInterval(
                                      param.data  , [0.0, 1.0]  , msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''  , )
                      elif "time_mix_value" in name:
                            if param.requires_grad:
                                  self.assertInterval(
                                      param.data  , [0.0, 1.3]  , msg=f'''Parameter {name} of model {model_class} seems not properly initialized'''  , )


    def        __a							(					self   ):
          UpperCamelCase__ ,     UpperCamelCase__  =    self.model_tester.prepare_config_and_inputs_for_common()
          UpperCamelCase__  =    True

          UpperCamelCase__  =    getattr(self.model_tester  , "seq_length"  , a   )

          for model_class in self.all_model_classes:
                UpperCamelCase__  =    True
                UpperCamelCase__  =    False
                UpperCamelCase__  =    True
                UpperCamelCase__  =    model_class(a   )
                model.to(a   )
                model.eval()

                UpperCamelCase__  =    self._prepare_for_class(a  , a   )
                UpperCamelCase__  =    inputs["input_ids"].shape[0]
                with torch.no_grad():
                      UpperCamelCase__  =    model(**a   )
                UpperCamelCase__  =    outputs.attentions
                self.assertEqual(len(a   )  , self.model_tester.num_hidden_layers   )

                # check that output_attentions also work using config
                del inputs_dict["output_attentions"]
                UpperCamelCase__  =    True
                UpperCamelCase__  =    model_class(a   )
                model.to(a   )
                model.eval()

                UpperCamelCase__  =    self._prepare_for_class(a  , a   )
                UpperCamelCase__  =    inputs["input_ids"].shape[0]
                with torch.no_grad():
                      UpperCamelCase__  =    model(**a   )
                UpperCamelCase__  =    outputs.attentions
                self.assertEqual(len(a   )  , self.model_tester.num_hidden_layers   )

                self.assertListEqual(
                    list(attentions[0].shape[-3:]   )  , [batch_size, seq_len, config.hidden_size]  , )
                UpperCamelCase__  =    len(a   )

                # Check attention is always last and order is fine
                UpperCamelCase__  =    True
                UpperCamelCase__  =    True
                UpperCamelCase__  =    model_class(a   )
                model.to(a   )
                model.eval()

                UpperCamelCase__  =    self._prepare_for_class(a  , a   )
                UpperCamelCase__  =    inputs["input_ids"].shape[0]
                with torch.no_grad():
                      UpperCamelCase__  =    model(**a   )

                UpperCamelCase__  =    1
                self.assertEqual(out_len + added_hidden_states  , len(a   )   )

                UpperCamelCase__  =    outputs.attentions

                self.assertEqual(len(a   )  , self.model_tester.num_hidden_layers   )
                self.assertListEqual(
                    list(self_attentions[0].shape[-3:]   )  , [batch_size, seq_len, config.hidden_size]  , )


    @slow
    def        __a							(					self   ):
          for model_name in RWKV_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                UpperCamelCase__  =    RwkvModel.from_pretrained(a   )
                self.assertIsNotNone(a   )

@unittest.skipIf(
    not is_torch_greater_or_equal_than_2_0  ,						reason='See https://github.com/huggingface/transformers/pull/24204'       )
@slow
class  lowercase_					(   unittest.TestCase       ):


    def        __a							(					self   ):
          UpperCamelCase__  =    "RWKV/rwkv-4-169m-pile"
          UpperCamelCase__  =    AutoTokenizer.from_pretrained(self.model_id   )


    def        __a							(					self   ):
          UpperCamelCase__  =    "Hello my name is Jasmine and I am a newbie to the"
          UpperCamelCase__  =    RwkvForCausalLM.from_pretrained(self.model_id   ).to(a   )

          UpperCamelCase__  =    self.tokenizer("Hello my name is"  , return_tensors="pt"   ).input_ids.to(a   )
          UpperCamelCase__  =    model.generate(a  , max_new_tokens=10   )
          UpperCamelCase__  =    self.tokenizer.decode(output[0].tolist()   )

          self.assertEqual(a  , a   )


    def        __a							(					self   ):
          UpperCamelCase__  =    "Hello my name is Jasmine and I am a newbie to the"

          UpperCamelCase__  =    self.tokenizer("Hello my name is"  , return_tensors="pt"   ).input_ids.to(a   )
          UpperCamelCase__  =    RwkvForCausalLM.from_pretrained(self.model_id  , torch_dtype=torch.bfloataa   ).to(a   )

          UpperCamelCase__  =    model.generate(a  , max_new_tokens=10   )
          UpperCamelCase__  =    self.tokenizer.decode(output[0].tolist()   )

          self.assertEqual(a  , a   )









'''simple docstring'''







import math







def _UpperCamelCase	(					__A   )							->		bool:


      '''simple docstring'''



      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5				,      int(math.sqrt(__A   ) + 1   )				,      6   ):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True







def _UpperCamelCase	(					__A = 1000				,      __A = 1000   )							->		int:


      '''simple docstring'''



      UpperCamelCase__  =    [0, 0, 0]  # length, a, b
      for a in range((a_limit * -1) + 1				,      __A   ):
            for b in range(2				,      __A   ):
                  if is_prime(__A   ):
                        UpperCamelCase__  =    0
                        UpperCamelCase__  =    0
                        while is_prime((n**2) + (a * n) + b   ):
                              count += 1
                              n += 1
                        if count > longest[0]:
                              UpperCamelCase__  =    [count, a, b]
      UpperCamelCase__  =    longest[1] * longest[2]
      return ans


if __name__ == "__main__":
  print(solution(1_0_0_0, 1_0_0_0))





