code: 
  
  import tempfile
  import unittest
  
  import numpy as np
  
  import transformers
  from transformers import GPTaTokenizer, GPTNeoConfig, 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, 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.gpt_neo.modeling_flax_gpt_neo import FlaxGPTNeoForCausalLM, FlaxGPTNeoModel
  
  if is_torch_available():
  			import torch
  
  
  
  
  
  
  class     lowerCamelCase_			:
  
  
  
  
  	def __init__(				self	:    int				,			__A	:    List[str]				,			__A	:    Optional[int]=14				,			__A	:    Dict=7				,			__A	:    Tuple=True				,			__A	:    Any=True				,			__A	:    Tuple=False				,			__A	:    str=True				,			__A	:    Tuple=99				,			__A	:    Tuple=32				,			__A	:    Optional[Any]=4				,			__A	:    Optional[int]=4				,			__A	:    Optional[Any]=[[["global", "local"], 2]]				,			__A	:    List[str]=37				,			__A	:    Dict="gelu"				,			__A	:    Optional[Any]=0.1				,			__A	:    Optional[Any]=0.1				,			__A	:    Optional[int]=512				,			__A	:    List[Any]=7				,			__A	:    List[str]=0.0_2				,			):
  		__A   : Union[str, Any]								= parent
  		__A   : Union[str, Any]								= batch_size
  		__A   : Any								= seq_length
  		__A   : str								= is_training
  		__A   : Union[str, Any]								= use_input_mask
  		__A   : List[Any]								= use_token_type_ids
  		__A   : str								= use_labels
  		__A   : Dict								= vocab_size
  		__A   : Union[str, Any]								= hidden_size
  		__A   : Dict								= num_hidden_layers
  		__A   : int								= num_attention_heads
  		__A   : Tuple								= attention_types
  		__A   : int								= intermediate_size
  		__A   : Optional[Any]								= hidden_act
  		__A   : int								= hidden_dropout_prob
  		__A   : List[str]								= attention_probs_dropout_prob
  		__A   : Optional[Any]								= max_position_embeddings
  		__A   : str								= window_size
  		__A   : Tuple								= initializer_range
  		__A   : Union[str, Any]								= None
  		__A   : int								= vocab_size - 1
  		__A   : Any								= vocab_size - 1
  		__A   : int								= vocab_size - 1
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Dict       ):
  		__A   : Tuple								= ids_tensor([self.batch_size, self.seq_length]				,			self.vocab_size       )
  
  		__A   : str								= None
  		if self.use_input_mask:
  			__A   : int								= random_attention_mask([self.batch_size, self.seq_length]       )
  
  		__A   : List[str]								= GPTNeoConfig(
  		    vocab_size=self.vocab_size				,			hidden_size=self.hidden_size				,			num_layers=self.num_hidden_layers				,			num_heads=self.num_attention_heads				,			max_position_embeddings=self.max_position_embeddings				,			use_cache=__A				,			bos_token_id=self.bos_token_id				,			eos_token_id=self.eos_token_id				,			pad_token_id=self.pad_token_id				,			window_size=self.window_size				,			attention_types=self.attention_types				,			)
  
  		return (config, input_ids, input_mask)
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    List[Any]       ):
  		__A   : int								= self.prepare_config_and_inputs()
  		__A   : Any								= config_and_inputs
  		__A   : Union[str, Any]								= {"""input_ids""": input_ids, """attention_mask""": attention_mask}
  		return config, inputs_dict
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Any				,			__A	:    Optional[int]				,			__A	:    Tuple				,			__A	:    int				,			__A	:    int       ):
  		__A   : List[str]								= 20
  		__A   : Optional[int]								= model_class_name(__A       )
  
  		__A   : Optional[int]								= model.init_cache(input_ids.shape[0]				,			__A       )
  		__A   : List[str]								= jnp.ones((input_ids.shape[0], max_decoder_length)				,			dtype="""i4"""       )
  
  		__A   : int								= jnp.broadcast_to(
  		    jnp.arange(input_ids.shape[-1] - 1       )[None, :]				,			(input_ids.shape[0], input_ids.shape[-1] - 1)       )
  		__A   : Dict								= model(
  		    input_ids[:, :-1]				,			attention_mask=__A				,			past_key_values=__A				,			position_ids=__A				,			)
  
  		__A   : List[Any]								= jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]				,			dtype="""i4"""       )
  		__A   : Optional[Any]								= model(
  		    input_ids[:, -1:]				,			attention_mask=__A				,			past_key_values=outputs_cache.past_key_values				,			position_ids=__A				,			)
  
  		__A   : Union[str, Any]								= model(__A       )
  
  		__A   : Any								= 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 					lowerCAmelCase_					(				self	:    int				,			__A	:    Union[str, Any]				,			__A	:    Any				,			__A	:    Union[str, Any]				,			__A	:    Union[str, Any]       ):
  		__A   : Dict								= 20
  		__A   : Tuple								= model_class_name(__A       )
  
  		__A   : Dict								= jnp.concatenate(
  		    [attention_mask, jnp.zeros((attention_mask.shape[0], max_decoder_length - attention_mask.shape[1])       )]				,			axis=-1				,			)
  
  		__A   : List[str]								= model.init_cache(input_ids.shape[0]				,			__A       )
  		__A   : int								= jnp.broadcast_to(
  		    jnp.arange(input_ids.shape[-1] - 1       )[None, :]				,			(input_ids.shape[0], input_ids.shape[-1] - 1)       )
  
  		__A   : Tuple								= model(
  		    input_ids[:, :-1]				,			attention_mask=__A				,			past_key_values=__A				,			position_ids=__A				,			)
  		__A   : Any								= jnp.array(input_ids.shape[0] * [[input_ids.shape[-1] - 1]]				,			dtype="""i4"""       )
  		__A   : List[str]								= model(
  		    input_ids[:, -1:]				,			past_key_values=outputs_cache.past_key_values				,			attention_mask=__A				,			position_ids=__A				,			)
  
  		__A   : List[str]								= model(__A				,			attention_mask=__A       )
  
  		__A   : List[Any]								= 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     lowerCamelCase_			(  _lowercase	,			_lowercase	,			unittest.TestCase  ):
  	_lowercase		:      List[Any]    				=							(FlaxGPTNeoModel, FlaxGPTNeoForCausalLM) if is_flax_available() else ()
  	_lowercase		:      Union[str, Any]    				=							(FlaxGPTNeoForCausalLM,) if is_flax_available() else ()
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Optional[int]       ):
  		__A   : Union[str, Any]								= FlaxGPTNeoModelTester(self       )
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Optional[int]       ):
  		for model_class_name in self.all_model_classes:
  			__A   : List[Any]								= self.model_tester.prepare_config_and_inputs()
  			self.model_tester.check_use_cache_forward(__A				,			__A				,			__A				,			__A       )
  
  
  
  
  	def 					lowerCAmelCase_					(				self	:    Optional[int]       ):
  		for model_class_name in self.all_model_classes:
  			__A   : str								= self.model_tester.prepare_config_and_inputs()
  			self.model_tester.check_use_cache_forward_with_attn_mask(
  			    __A				,			__A				,			__A				,			__A       )
  
  
  
  
  	@slow
  	def 					lowerCAmelCase_					(				self	:    Dict       ):
  		__A   : str								= GPTaTokenizer.from_pretrained("""gpt2"""				,			pad_token="""<|endoftext|>"""				,			padding_side="""left"""       )
  		__A   : Dict								= tokenizer(["""Hello this is a long string""", """Hey"""]				,			return_tensors="""np"""				,			padding=__A				,			truncation=__A       )
  
  		__A   : Union[str, Any]								= FlaxGPTNeoForCausalLM.from_pretrained("""EleutherAI/gpt-neo-125M"""       )
  		__A   : str								= False
  		__A   : Tuple								= model.config.eos_token_id
  
  		__A   : List[str]								= jax.jit(model.generate       )
  
  		__A   : Optional[Any]								= jit_generate(
  		    inputs["""input_ids"""]				,			attention_mask=inputs["""attention_mask"""]				,			pad_token_id=tokenizer.pad_token_id       ).sequences
  
  		__A   : Optional[int]								= tokenizer.batch_decode(__A				,			skip_special_tokens=__A       )
  
  		__A   : Union[str, Any]								= [
  		    """Hello this is a long string of text.\n\nI'm trying to get the text of the""",
  		    """Hey, I'm a little late to the party. I'm going to""",
  		]
  
  		self.assertListEqual(__A				,			__A       )
  
  
  
  
  	@is_pt_flax_cross_test
  	def 					lowerCAmelCase_					(				self	:    Any       ):
  		__A   : int								= 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
  				__A   : Dict								= self._prepare_for_class(__A				,			__A       )
  				__A   : List[Any]								= {k: torch.tensor(v.tolist()       ) for k, v in prepared_inputs_dict.items()}
  
  				# load corresponding PyTorch class
  				__A   : Union[str, Any]								= model_class.__name__[4:]  # Skip the "Flax" at the beginning
  				__A   : str								= getattr(__A				,			__A       )
  
  				__A   : List[Any]								= pt_inputs["""input_ids"""].shape
  				__A   : Tuple								= np.random.randint(0				,			seq_length - 1				,			size=(batch_size,)       )
  				for batch_idx, start_index in enumerate(__A       ):
  					__A   : Tuple								= 0
  					__A   : str								= 1
  					__A   : int								= 0
  					__A   : Optional[int]								= 1
  				__A   : int								= pt_model_class(__A       ).eval()
  				__A   : int								= model_class(__A				,			dtype=jnp.floataa       )
  
  				__A   : Tuple								= convert_pytorch_state_dict_to_flax(pt_model.state_dict()				,			__A       )
  				__A   : Union[str, Any]								= fx_state
  
  				with torch.no_grad():
  					__A   : List[str]								= pt_model(**__A       ).to_tuple()
  
  				__A   : int								= fx_model(**__A       ).to_tuple()
  				self.assertEqual(len(__A       )				,			len(__A       )				,			"""Output lengths differ between Flax and PyTorch"""       )
  				for fx_output, pt_output in zip(__A				,			__A       ):
  					self.assert_almost_equals(fx_output[:, -1]				,			pt_output[:, -1].numpy()				,			4e-2       )
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  					pt_model.save_pretrained(__A       )
  					__A   : Tuple								= model_class.from_pretrained(__A				,			from_pt=__A       )
  
  				__A   : List[str]								= fx_model_loaded(**__A       ).to_tuple()
  				self.assertEqual(
  				    len(__A       )				,			len(__A       )				,			"""Output lengths differ between Flax and PyTorch"""       )
  				for fx_output_loaded, pt_output in zip(__A				,			__A       ):
  					self.assert_almost_equals(fx_output_loaded[:, -1]				,			pt_output[:, -1].numpy()				,			4e-2       )
  
  
  
  
  	@is_pt_flax_cross_test
  	def 					lowerCAmelCase_					(				self	:    Tuple       ):
  		__A   : int								= 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
  				__A   : Optional[int]								= self._prepare_for_class(__A				,			__A       )
  				__A   : Tuple								= {k: torch.tensor(v.tolist()       ) for k, v in prepared_inputs_dict.items()}
  
  				# load corresponding PyTorch class
  				__A   : Optional[Any]								= model_class.__name__[4:]  # Skip the "Flax" at the beginning
  				__A   : Union[str, Any]								= getattr(__A				,			__A       )
  
  				__A   : Union[str, Any]								= pt_model_class(__A       ).eval()
  				__A   : Tuple								= model_class(__A				,			dtype=jnp.floataa       )
  
  				__A   : Union[str, Any]								= load_flax_weights_in_pytorch_model(__A				,			fx_model.params       )
  				__A   : int								= pt_inputs["""input_ids"""].shape
  				__A   : int								= np.random.randint(0				,			seq_length - 1				,			size=(batch_size,)       )
  				for batch_idx, start_index in enumerate(__A       ):
  					__A   : Any								= 0
  					__A   : List[Any]								= 1
  					__A   : Tuple								= 0
  					__A   : Union[str, Any]								= 1
  
  				# make sure weights are tied in PyTorch
  				pt_model.tie_weights()
  
  				with torch.no_grad():
  					__A   : Union[str, Any]								= pt_model(**__A       ).to_tuple()
  
  				__A   : List[Any]								= fx_model(**__A       ).to_tuple()
  				self.assertEqual(len(__A       )				,			len(__A       )				,			"""Output lengths differ between Flax and PyTorch"""       )
  				for fx_output, pt_output in zip(__A				,			__A       ):
  					self.assert_almost_equals(fx_output[:, -1]				,			pt_output[:, -1].numpy()				,			4e-2       )
  
  				with tempfile.TemporaryDirectory() as tmpdirname:
  					fx_model.save_pretrained(__A       )
  					__A   : Tuple								= pt_model_class.from_pretrained(__A				,			from_flax=__A       )
  
  				with torch.no_grad():
  					__A   : Optional[int]								= pt_model_loaded(**__A       ).to_tuple()
  
  				self.assertEqual(
  				    len(__A       )				,			len(__A       )				,			"""Output lengths differ between Flax and PyTorch"""       )
  				for fx_output, pt_output in zip(__A				,			__A       ):
  					self.assert_almost_equals(fx_output[:, -1]				,			pt_output[:, -1].numpy()				,			4e-2       )
  
  
  
  
  	@slow
  	def 					lowerCAmelCase_					(				self	:    Any       ):
  		for model_class_name in self.all_model_classes:
  			__A   : List[str]								= model_class_name.from_pretrained("""EleutherAI/gpt-neo-125M"""       )
  			__A   : List[str]								= model(np.ones((1, 1)       )       )
  			self.assertIsNotNone(__A       )
  
  
  
  
  
  
style_context: 
  
  UpperCAmelCase_       :				str		   =      [
      [0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0],
      [0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0],
      [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0],
  ]
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      int ,a__						:      int					)				->							bool:
  	return 0 <= row < rows and 0 <= col < cols
  def        __SCREAMING_SNAKE_CASE    (      a__						:      int ,a__						:      int ,a__						:      set ,a__						:      list[list[int]]					)				->							int:
  	__A   : Union[str, Any]								= len(a__					)
  	__A   : Any								= len(mat[0]					)
  	if is_safe(a__ ,a__ ,a__ ,a__					) and (row, col) not in seen and mat[row][col] == 1:
  		seen.add((row, col)					)
  		return (
  		    1
  		    + depth_first_search(row + 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(row - 1 ,a__ ,a__ ,a__					)
  		    + depth_first_search(a__ ,col + 1 ,a__ ,a__					)
  		    + depth_first_search(a__ ,col - 1 ,a__ ,a__					)
  		)
  	else:
  		return 0
  def        __SCREAMING_SNAKE_CASE    (      a__						:      list[list[int]]					)				->							int:
  	__A   : set								= set()
  
  	__A   : Union[str, Any]								= 0
  	for row, line in enumerate(a__					):
  		for col, item in enumerate(a__					):
  			if item == 1 and (row, col) not in seen:
  				# Maximizing the area
  				__A   : Optional[Any]								= max(a__ ,depth_first_search(a__ ,a__ ,a__ ,a__					)					)
  	return max_area
  
  
  if __name__ == "__main__":
  			import doctest
  
  			print(find_max_area(matrix))  # Output -> 6
  			doctest.testmod()
  
  
  
  
  
  