





import unittest

from parameterized import parameterized

from transformers import OpenLlamaConfig, is_torch_available, set_seed
from transformers.testing_utils import require_torch, torch_device

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


if is_torch_available():
     import torch

     from transformers import OpenLlamaForCausalLM, OpenLlamaForSequenceClassification, OpenLlamaModel



class   _SCREAMING_SNAKE_CASE		:







 '''simple docstring'''

 def __init__(self							:  Tuple			,					UpperCAmelCase_							:  Optional[int]			,					UpperCAmelCase_							:  Any=13			,					UpperCAmelCase_							:  Union[str, Any]=7			,					UpperCAmelCase_							:  Optional[Any]=True			,					UpperCAmelCase_							:  Optional[int]=True			,					UpperCAmelCase_							:  int=False			,					UpperCAmelCase_							:  Any=True			,					UpperCAmelCase_							:  str=99			,					UpperCAmelCase_							:  Union[str, Any]=32			,					UpperCAmelCase_							:  Optional[int]=5			,					UpperCAmelCase_							:  List[str]=4			,					UpperCAmelCase_							:  List[Any]=37			,					UpperCAmelCase_							:  str="gelu"			,					UpperCAmelCase_							:  Tuple=0.1			,					UpperCAmelCase_							:  str=0.1			,					UpperCAmelCase_							:  Union[str, Any]=512			,					UpperCAmelCase_							:  Union[str, Any]=16			,					UpperCAmelCase_							:  List[Any]=2			,					UpperCAmelCase_							:  int=0.02			,					UpperCAmelCase_							:  List[str]=3			,					UpperCAmelCase_							:  Optional[int]=4			,					UpperCAmelCase_							:  Any=None			,					)			->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__: Dict         =parent
   lowerCamelCase__: str         =batch_size
   lowerCamelCase__: Optional[int]         =seq_length
   lowerCamelCase__: Dict         =is_training
   lowerCamelCase__: Optional[int]         =use_input_mask
   lowerCamelCase__: Dict         =use_token_type_ids
   lowerCamelCase__: Optional[Any]         =use_labels
   lowerCamelCase__: str         =vocab_size
   lowerCamelCase__: int         =hidden_size
   lowerCamelCase__: List[str]         =num_hidden_layers
   lowerCamelCase__: int         =num_attention_heads
   lowerCamelCase__: Any         =intermediate_size
   lowerCamelCase__: Tuple         =hidden_act
   lowerCamelCase__: List[Any]         =hidden_dropout_prob
   lowerCamelCase__: List[str]         =attention_probs_dropout_prob
   lowerCamelCase__: Union[str, Any]         =max_position_embeddings
   lowerCamelCase__: Optional[Any]         =type_vocab_size
   lowerCamelCase__: Tuple         =type_sequence_label_size
   lowerCamelCase__: int         =initializer_range
   lowerCamelCase__: Union[str, Any]         =num_labels
   lowerCamelCase__: Union[str, Any]         =num_choices
   lowerCamelCase__: str         =scope

 def 				SCREAMING_SNAKE_CASE_   (self							:  Union[str, Any])			->int:



   '''simple docstring'''



   lowerCamelCase__: List[str]         =ids_tensor([self.batch_size, self.seq_length]			,					self.vocab_size)

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

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

   lowerCamelCase__: List[str]         =None
   lowerCamelCase__: int         =None
   lowerCamelCase__: str         =None
   if self.use_labels:
     lowerCamelCase__: Dict         =ids_tensor([self.batch_size]			,					self.type_sequence_label_size)
     lowerCamelCase__: Optional[Any]         =ids_tensor([self.batch_size, self.seq_length]			,					self.num_labels)
     lowerCamelCase__: List[Any]         =ids_tensor([self.batch_size]			,					self.num_choices)

   lowerCamelCase__: List[Any]         =self.get_config()

   return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels

 def 				SCREAMING_SNAKE_CASE_   (self							:  Dict)			->Dict:



   '''simple docstring'''



   return OpenLlamaConfig(
       vocab_size=self.vocab_size			,					hidden_size=self.hidden_size			,					num_hidden_layers=self.num_hidden_layers			,					num_attention_heads=self.num_attention_heads			,					intermediate_size=self.intermediate_size			,					hidden_act=self.hidden_act			,					hidden_dropout_prob=self.hidden_dropout_prob			,					attention_probs_dropout_prob=self.attention_probs_dropout_prob			,					max_position_embeddings=self.max_position_embeddings			,					type_vocab_size=self.type_vocab_size			,					is_decoder=UpperCAmelCase_			,					initializer_range=self.initializer_range			,					use_stable_embedding=UpperCAmelCase_			,					)

 def 				SCREAMING_SNAKE_CASE_   (self							:  Any			,					UpperCAmelCase_							:  Optional[Any]			,					UpperCAmelCase_							:  Union[str, Any]			,					UpperCAmelCase_							:  str			,					UpperCAmelCase_							:  Tuple			,					UpperCAmelCase_							:  int			,					UpperCAmelCase_							:  Any			,					UpperCAmelCase_							:  Optional[int])			->Tuple:



   '''simple docstring'''



   lowerCamelCase__: List[str]         =OpenLlamaModel(config=UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()
   lowerCamelCase__: Any         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_)
   lowerCamelCase__: Tuple         =model(UpperCAmelCase_)
   self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, self.seq_length, self.hidden_size))

 def 				SCREAMING_SNAKE_CASE_   (self							:  Dict			,					UpperCAmelCase_							:  List[Any]			,					UpperCAmelCase_							:  str			,					UpperCAmelCase_							:  Union[str, Any]			,					UpperCAmelCase_							:  Tuple			,					UpperCAmelCase_							:  Optional[Any]			,					UpperCAmelCase_							:  Dict			,					UpperCAmelCase_							:  Optional[Any]			,					UpperCAmelCase_							:  Optional[int]			,					UpperCAmelCase_							:  Any			,					)			->Dict:



   '''simple docstring'''



   lowerCamelCase__: Optional[Any]         =True
   lowerCamelCase__: List[str]         =OpenLlamaModel(UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()
   lowerCamelCase__: str         =model(
       UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					encoder_hidden_states=UpperCAmelCase_			,					encoder_attention_mask=UpperCAmelCase_			,					)
   lowerCamelCase__: Dict         =model(
       UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					encoder_hidden_states=UpperCAmelCase_			,					)
   lowerCamelCase__: List[str]         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_)
   self.parent.assertEqual(result.last_hidden_state.shape			,					(self.batch_size, self.seq_length, self.hidden_size))

 def 				SCREAMING_SNAKE_CASE_   (self							:  Optional[Any]			,					UpperCAmelCase_							:  Optional[Any]			,					UpperCAmelCase_							:  str			,					UpperCAmelCase_							:  int			,					UpperCAmelCase_							:  Optional[int]			,					UpperCAmelCase_							:  Optional[Any]			,					UpperCAmelCase_							:  Dict			,					UpperCAmelCase_							:  Any			,					UpperCAmelCase_							:  str			,					UpperCAmelCase_							:  Optional[int]			,					)			->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__: str         =OpenLlamaForCausalLM(config=UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()
   lowerCamelCase__: Tuple         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					labels=UpperCAmelCase_)
   self.parent.assertEqual(result.logits.shape			,					(self.batch_size, self.seq_length, self.vocab_size))

 def 				SCREAMING_SNAKE_CASE_   (self							:  Optional[Any]			,					UpperCAmelCase_							:  int			,					UpperCAmelCase_							:  Any			,					UpperCAmelCase_							:  int			,					UpperCAmelCase_							:  Tuple			,					UpperCAmelCase_							:  Tuple			,					UpperCAmelCase_							:  Dict			,					UpperCAmelCase_							:  int			,					UpperCAmelCase_							:  Any			,					UpperCAmelCase_							:  Any			,					)			->Any:



   '''simple docstring'''



   lowerCamelCase__: Optional[int]         =True
   lowerCamelCase__: Any         =True
   lowerCamelCase__: int         =OpenLlamaForCausalLM(config=UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()

   # first forward pass
   lowerCamelCase__: str         =model(
       UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					encoder_hidden_states=UpperCAmelCase_			,					encoder_attention_mask=UpperCAmelCase_			,					use_cache=UpperCAmelCase_			,					)
   lowerCamelCase__: Dict         =outputs.past_key_values

   # create hypothetical multiple next token and extent to next_input_ids
   lowerCamelCase__: Optional[int]         =ids_tensor((self.batch_size, 3)			,					config.vocab_size)
   lowerCamelCase__: Optional[Any]         =ids_tensor((self.batch_size, 3)			,					vocab_size=2)

   # append to next input_ids and
   lowerCamelCase__: Any         =torch.cat([input_ids, next_tokens]			,					dim=-1)
   lowerCamelCase__: Dict         =torch.cat([input_mask, next_mask]			,					dim=-1)

   lowerCamelCase__: Optional[int]         =model(
       UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					encoder_hidden_states=UpperCAmelCase_			,					encoder_attention_mask=UpperCAmelCase_			,					output_hidden_states=UpperCAmelCase_			,					)["hidden_states"][0]
   lowerCamelCase__: str         =model(
       UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					encoder_hidden_states=UpperCAmelCase_			,					encoder_attention_mask=UpperCAmelCase_			,					past_key_values=UpperCAmelCase_			,					output_hidden_states=UpperCAmelCase_			,					)["hidden_states"][0]

   # select random slice
   lowerCamelCase__: str         =ids_tensor((1,)			,					output_from_past.shape[-1]).item()
   lowerCamelCase__: List[str]         =output_from_no_past[:, -3:, random_slice_idx].detach()
   lowerCamelCase__: Union[str, Any]         =output_from_past[:, :, random_slice_idx].detach()

   self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1])

   # test that outputs are equal for slice
   self.parent.assertTrue(torch.allclose(UpperCAmelCase_			,					UpperCAmelCase_			,					atol=1E-3))







 def 				SCREAMING_SNAKE_CASE_   (self							:  Dict)			->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__: Optional[Any]         =self.prepare_config_and_inputs()
   (
       (
       lowerCamelCase__
   )    ,   (
       lowerCamelCase__
   )    ,   (
       lowerCamelCase__
   )    ,   (
       lowerCamelCase__
   )    ,   (
       lowerCamelCase__
   )    ,   (
       lowerCamelCase__
   )    ,   (
       lowerCamelCase__
   )    ,   
   ): Optional[int]         =config_and_inputs
   lowerCamelCase__: Optional[int]         ={"input_ids": input_ids, "attention_mask": input_mask}
   return config, inputs_dict



@require_torch
class   _SCREAMING_SNAKE_CASE		(      __SCREAMING_SNAKE_CASE       ,				__SCREAMING_SNAKE_CASE       ,				__SCREAMING_SNAKE_CASE       ,				unittest.TestCase       ):







 '''simple docstring'''
 lowercase_						=     (
     (OpenLlamaModel, OpenLlamaForCausalLM, OpenLlamaForSequenceClassification) if is_torch_available() else ()
 )
 lowercase_						=     (OpenLlamaForCausalLM,) if is_torch_available() else ()
 lowercase_						=     (
     {
         "feature-extraction": OpenLlamaModel,
         "text-classification": OpenLlamaForSequenceClassification,
         "text-generation": OpenLlamaForCausalLM,
         "zero-shot": OpenLlamaForSequenceClassification,
     }
     if is_torch_available()
     else {}
 )
 lowercase_						=     False
 lowercase_						=     False

 def 				SCREAMING_SNAKE_CASE_   (self							:  Any)			->Optional[int]:



   '''simple docstring'''



   lowerCamelCase__: str         =OpenLlamaModelTester(self)
   lowerCamelCase__: Optional[Any]         =ConfigTester(self			,					config_class=UpperCAmelCase_			,					hidden_size=37)

 def 				SCREAMING_SNAKE_CASE_   (self							:  List[str])			->List[str]:



   '''simple docstring'''



   self.config_tester.run_common_tests()

 def 				SCREAMING_SNAKE_CASE_   (self							:  List[str])			->str:



   '''simple docstring'''



   lowerCamelCase__: List[Any]         =self.model_tester.prepare_config_and_inputs()
   self.model_tester.create_and_check_model(*UpperCAmelCase_)

 def 				SCREAMING_SNAKE_CASE_   (self							:  Any)			->Optional[Any]:



   '''simple docstring'''



   lowerCamelCase__: Tuple         =self.model_tester.prepare_config_and_inputs()
   for type in ["absolute", "relative_key", "relative_key_query"]:
     lowerCamelCase__: str         =type
     self.model_tester.create_and_check_model(*UpperCAmelCase_)

 def 				SCREAMING_SNAKE_CASE_   (self							:  Any)			->Dict:



   '''simple docstring'''



   lowerCamelCase__    ,   lowerCamelCase__: Optional[int]         =self.model_tester.prepare_config_and_inputs_for_common()
   lowerCamelCase__: Union[str, Any]         =3
   lowerCamelCase__: Union[str, Any]         =input_dict["input_ids"]
   lowerCamelCase__: Dict         =input_ids.ne(1).to(UpperCAmelCase_)
   lowerCamelCase__: Any         =ids_tensor([self.model_tester.batch_size]			,					self.model_tester.type_sequence_label_size)
   lowerCamelCase__: Dict         =OpenLlamaForSequenceClassification(UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()
   lowerCamelCase__: Optional[Any]         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					labels=UpperCAmelCase_)
   self.assertEqual(result.logits.shape			,					(self.model_tester.batch_size, self.model_tester.num_labels))

 def 				SCREAMING_SNAKE_CASE_   (self							:  List[str])			->Union[str, Any]:



   '''simple docstring'''



   lowerCamelCase__    ,   lowerCamelCase__: str         =self.model_tester.prepare_config_and_inputs_for_common()
   lowerCamelCase__: Tuple         =3
   lowerCamelCase__: str         ="single_label_classification"
   lowerCamelCase__: Tuple         =input_dict["input_ids"]
   lowerCamelCase__: Tuple         =input_ids.ne(1).to(UpperCAmelCase_)
   lowerCamelCase__: Any         =ids_tensor([self.model_tester.batch_size]			,					self.model_tester.type_sequence_label_size)
   lowerCamelCase__: Optional[int]         =OpenLlamaForSequenceClassification(UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()
   lowerCamelCase__: Optional[int]         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					labels=UpperCAmelCase_)
   self.assertEqual(result.logits.shape			,					(self.model_tester.batch_size, self.model_tester.num_labels))

 def 				SCREAMING_SNAKE_CASE_   (self							:  List[Any])			->str:



   '''simple docstring'''



   lowerCamelCase__    ,   lowerCamelCase__: Tuple         =self.model_tester.prepare_config_and_inputs_for_common()
   lowerCamelCase__: List[Any]         =3
   lowerCamelCase__: str         ="multi_label_classification"
   lowerCamelCase__: Dict         =input_dict["input_ids"]
   lowerCamelCase__: Tuple         =input_ids.ne(1).to(UpperCAmelCase_)
   lowerCamelCase__: int         =ids_tensor(
       [self.model_tester.batch_size, config.num_labels]			,					self.model_tester.type_sequence_label_size).to(torch.float)
   lowerCamelCase__: List[Any]         =OpenLlamaForSequenceClassification(UpperCAmelCase_)
   model.to(UpperCAmelCase_)
   model.eval()
   lowerCamelCase__: Union[str, Any]         =model(UpperCAmelCase_			,					attention_mask=UpperCAmelCase_			,					labels=UpperCAmelCase_)
   self.assertEqual(result.logits.shape			,					(self.model_tester.batch_size, self.model_tester.num_labels))

 @unittest.skip("Open-Llama buffers include complex numbers, which breaks this test")
 def 				SCREAMING_SNAKE_CASE_   (self							:  Any)			->Dict:



   '''simple docstring'''



   pass







 @parameterized.expand([("linear",), ("dynamic",)])
 def 				SCREAMING_SNAKE_CASE_   (self							:  Union[str, Any]			,					UpperCAmelCase_							:  List[Any])			->List[str]:



   '''simple docstring'''



   lowerCamelCase__    ,   lowerCamelCase__: Optional[Any]         =self.model_tester.prepare_config_and_inputs_for_common()
   lowerCamelCase__: Any         =ids_tensor([1, 10]			,					config.vocab_size)
   lowerCamelCase__: List[Any]         =ids_tensor([1, int(config.max_position_embeddings * 1.5)]			,					config.vocab_size)

   set_seed(42)  # Fixed seed at init time so the two models get the same random weights
   lowerCamelCase__: str         =OpenLlamaModel(UpperCAmelCase_)
   original_model.to(UpperCAmelCase_)
   original_model.eval()
   lowerCamelCase__: Tuple         =original_model(UpperCAmelCase_).last_hidden_state
   lowerCamelCase__: int         =original_model(UpperCAmelCase_).last_hidden_state

   set_seed(42)  # Fixed seed at init time so the two models get the same random weights
   lowerCamelCase__: Union[str, Any]         ={"type": scaling_type, "factor": 10.0}
   lowerCamelCase__: Optional[int]         =OpenLlamaModel(UpperCAmelCase_)
   scaled_model.to(UpperCAmelCase_)
   scaled_model.eval()
   lowerCamelCase__: Any         =scaled_model(UpperCAmelCase_).last_hidden_state
   lowerCamelCase__: Any         =scaled_model(UpperCAmelCase_).last_hidden_state

   # Dynamic scaling does not change the RoPE embeddings until it receives an input longer than the original
   # maximum sequence length, so the outputs for the short input should match.
   if scaling_type == "dynamic":
     self.assertTrue(torch.allclose(UpperCAmelCase_			,					UpperCAmelCase_			,					atol=1E-5))
   else:
     self.assertFalse(torch.allclose(UpperCAmelCase_			,					UpperCAmelCase_			,					atol=1E-5))

   # The output should be different for long inputs
   self.assertFalse(torch.allclose(UpperCAmelCase_			,					UpperCAmelCase_			,					atol=1E-5))





import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)



class 						_UpperCAmelCase      (     unittest.TestCase							):






		def _snake_case		(						self				:     Union[str, Any]):
				SCREAMING_SNAKE_CASE_				:Optional[int]				     =						["a", "b", "c"]

				# Defaults to last layer if both are None
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:Dict				     =						get_aligned_output_features_output_indices(UpperCAmelCase   ,  UpperCAmelCase   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["c"])
				self.assertEqual(UpperCAmelCase   ,  [2])

				# Out indices set to match out features
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:Tuple				     =						get_aligned_output_features_output_indices(["a", "c"]   ,  UpperCAmelCase   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["a", "c"])
				self.assertEqual(UpperCAmelCase   ,  [0, 2])

				# Out features set to match out indices
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:int				     =						get_aligned_output_features_output_indices(UpperCAmelCase   ,  [0, 2]   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["a", "c"])
				self.assertEqual(UpperCAmelCase   ,  [0, 2])

				# Out features selected from negative indices
				SCREAMING_SNAKE_CASE_     ,				SCREAMING_SNAKE_CASE_				:Any				     =						get_aligned_output_features_output_indices(UpperCAmelCase   ,  [-3, -1]   ,  UpperCAmelCase)
				self.assertEqual(UpperCAmelCase   ,  ["a", "c"])
				self.assertEqual(UpperCAmelCase   ,  [-3, -1])






		def _snake_case		(						self				:     str):
				# Stage names must be set
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0, 1)   ,  UpperCAmelCase)

				# Out features must be a list
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(("a", "b")   ,  (0, 1)   ,  ["a", "b"])

				# Out features must be a subset of stage names
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0, 1)   ,  ["a"])

				# Out indices must be a list or tuple
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(UpperCAmelCase   ,  0   ,  ["a", "b"])

				# Out indices must be a subset of stage names
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(UpperCAmelCase   ,  (0, 1)   ,  ["a"])

				# Out features and out indices must be the same length
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0,)   ,  ["a", "b", "c"])

				# Out features should match out indices
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["a", "b"]   ,  (0, 2)   ,  ["a", "b", "c"])

				# Out features and out indices should be in order
				with self.assertRaises(UpperCAmelCase):
						verify_out_features_out_indices(["b", "a"]   ,  (0, 1)   ,  ["a", "b"])

				# Check passes with valid inputs
				verify_out_features_out_indices(["a", "b", "d"]   ,  (0, 1, -1)   ,  ["a", "b", "c", "d"])







		def _snake_case		(						self				:     Tuple):
				SCREAMING_SNAKE_CASE_				:int				     =						BackboneMixin()

				SCREAMING_SNAKE_CASE_				:List[str]				     =						["a", "b", "c"]
				SCREAMING_SNAKE_CASE_				:str				     =						["a", "c"]
				SCREAMING_SNAKE_CASE_				:Union[str, Any]				     =						[0, 2]

				# Check that the output features and indices are set correctly
				self.assertEqual(backbone.out_features   ,  ["a", "c"])
				self.assertEqual(backbone.out_indices   ,  [0, 2])

				# Check out features and indices are updated correctly
				SCREAMING_SNAKE_CASE_				:Tuple				     =						["a", "b"]
				self.assertEqual(backbone.out_features   ,  ["a", "b"])
				self.assertEqual(backbone.out_indices   ,  [0, 1])

				SCREAMING_SNAKE_CASE_				:List[str]				     =						[-3, -1]
				self.assertEqual(backbone.out_features   ,  ["a", "c"])
				self.assertEqual(backbone.out_indices   ,  [-3, -1])






