



'''simple docstring'''

from typing import Any

class 							a__:






			def __init__(     self					,   _UpperCAmelCase						)							->							Any:
					snake_case__	     =data
					snake_case__	     =None






			def __repr__(     self						)							->							str:
					return f"""Node({self.data})"""





class 							a__:






			def __init__(     self						)							->							List[Any]:
					snake_case__	     =None






			def __iter__(     self						)							->							Any:
					snake_case__	     =self.head
					while node:
							yield node.data
							snake_case__	     =node.next






			def __len__(     self						)							->							int:
					return sum(1 for _ in self						)






			def __repr__(     self						)							->							str:
					return "->".join([str(_UpperCAmelCase						) for item in self]						)






			def __getitem__(     self					,   _UpperCAmelCase						)							->							Any:
					if not 0 <= index < len(self						):
							raise ValueError('list index out of range.'						)
					for i, node in enumerate(self						):
							if i == index:
									return node
					return None






			def __setitem__(     self					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							None:
					if not 0 <= index < len(self						):
							raise ValueError('list index out of range.'						)
					snake_case__	     =self.head
					for _ in range(_UpperCAmelCase						):
							snake_case__	     =current.next
					snake_case__	     =data






			def 						_lowercase  (     self					,   _UpperCAmelCase						)							->							None:
					self.insert_nth(len(self						)					,   _UpperCAmelCase						)






			def 						_lowercase  (     self					,   _UpperCAmelCase						)							->							None:
					self.insert_nth(0					,   _UpperCAmelCase						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							None:
					if not 0 <= index <= len(self						):
							raise IndexError('list index out of range'						)
					snake_case__	     =Node(_UpperCAmelCase						)
					if self.head is None:
							snake_case__	     =new_node
					elif index == 0:
							snake_case__	     =self.head  # link new_node to head
							snake_case__	     =new_node
					else:
							snake_case__	     =self.head
							for _ in range(index - 1						):
									snake_case__	     =temp.next
							snake_case__	     =temp.next
							snake_case__	     =new_node






			def 						_lowercase  (     self						)							->							None:  # print every node data
					print(self						)






			def 						_lowercase  (     self						)							->							Any:
					return self.delete_nth(0						)






			def 						_lowercase  (     self						)							->							Any:  # delete from tail
					return self.delete_nth(len(self						) - 1						)






			def 						_lowercase  (     self					,   _UpperCAmelCase = 0						)							->							Any:
					if not 0 <= index <= len(self						) - 1:  # test if index is valid
							raise IndexError('List index out of range.'						)
					snake_case__	     =self.head  # default first node
					if index == 0:
							snake_case__	     =self.head.next
					else:
							snake_case__	     =self.head
							for _ in range(index - 1						):
									snake_case__	     =temp.next
							snake_case__	     =temp.next
							snake_case__	     =temp.next.next
					return delete_node.data






			def 						_lowercase  (     self						)							->							bool:
					return self.head is None






			def 						_lowercase  (     self						)							->							None:
					snake_case__	     =None
					snake_case__	     =self.head

					while current:
							# Store the current node's next node.
							snake_case__	     =current.next
							# Make the current node's next point backwards
							snake_case__	     =prev
							# Make the previous node be the current node
							snake_case__	     =current
							# Make the current node the next node (to progress iteration)
							snake_case__	     =next_node
					# Return prev in order to put the head at the end
					snake_case__	     =prev






def 				a  (     )       ->	None:
		snake_case__	     =LinkedList()
		assert linked_list.is_empty() is True
		assert str(UpperCamelCase_			) == ""

		try:
				linked_list.delete_head()
				raise AssertionError  # This should not happen.
		except IndexError:
				assert True  # This should happen.

		try:
				linked_list.delete_tail()
				raise AssertionError  # This should not happen.
		except IndexError:
				assert True  # This should happen.

		for i in range(10			):
				assert len(UpperCamelCase_			) == i
				linked_list.insert_nth(UpperCamelCase_      ,					i + 1			)
		assert str(UpperCamelCase_			) == "->".join(str(UpperCamelCase_			) for i in range(1      ,					11			)			)

		linked_list.insert_head(0			)
		linked_list.insert_tail(11			)
		assert str(UpperCamelCase_			) == "->".join(str(UpperCamelCase_			) for i in range(0      ,					12			)			)

		assert linked_list.delete_head() == 0
		assert linked_list.delete_nth(9			) == 10
		assert linked_list.delete_tail() == 11
		assert len(UpperCamelCase_			) == 9
		assert str(UpperCamelCase_			) == "->".join(str(UpperCamelCase_			) for i in range(1      ,					10			)			)

		assert all(linked_list[i] == i + 1 for i in range(0      ,					9			)			) is True

		for i in range(0      ,					9			):
				snake_case__	     =-i
		assert all(linked_list[i] == -i for i in range(0      ,					9			)			) is True

		linked_list.reverse()
		assert str(UpperCamelCase_			) == "->".join(str(UpperCamelCase_			) for i in range(-8      ,					1			)			)






def 				a  (     )       ->	None:
		snake_case__	     =[
		    -9,
		    100,
		    Node(77345112			),
		    'dlrow olleH',
		    7,
		    5555,
		    0,
		    -1_9_2.5_5_5_5_5,
		    'Hello, world!',
		    7_7.9,
		    Node(10			),
		    None,
		    None,
		    1_2.2_0,
		]
		snake_case__	     =LinkedList()

		for i in test_input:
				linked_list.insert_tail(UpperCamelCase_			)

		# Check if it's empty or not
		assert linked_list.is_empty() is False
		assert (
		    str(UpperCamelCase_			) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
		    "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
		)

		# Delete the head
		snake_case__	     =linked_list.delete_head()
		assert result == -9
		assert (
		    str(UpperCamelCase_			) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
		    "Hello, world!->77.9->Node(10)->None->None->12.2"
		)

		# Delete the tail
		snake_case__	     =linked_list.delete_tail()
		assert result == 1_2.2
		assert (
		    str(UpperCamelCase_			) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
		    "Hello, world!->77.9->Node(10)->None->None"
		)

		# Delete a node in specific location in linked list
		snake_case__	     =linked_list.delete_nth(10			)
		assert result is None
		assert (
		    str(UpperCamelCase_			) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
		    "Hello, world!->77.9->Node(10)->None"
		)

		# Add a Node instance to its head
		linked_list.insert_head(Node('Hello again, world!'			)			)
		assert (
		    str(UpperCamelCase_			)
		    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
		    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
		)

		# Add None to its tail
		linked_list.insert_tail(UpperCamelCase_			)
		assert (
		    str(UpperCamelCase_			)
		    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
		    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
		)

		# Reverse the linked list
		linked_list.reverse()
		assert (
		    str(UpperCamelCase_			)
		    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
		    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
		)






def 				a  (     )       ->	Dict:
		from doctest import testmod

		testmod()

		snake_case__	     =LinkedList()
		linked_list.insert_head(input('Inserting 1st at head '			).strip()			)
		linked_list.insert_head(input('Inserting 2nd at head '			).strip()			)
		print('\nPrint list:'			)
		linked_list.print_list()
		linked_list.insert_tail(input('\nInserting 1st at tail '			).strip()			)
		linked_list.insert_tail(input('Inserting 2nd at tail '			).strip()			)
		print('\nPrint list:'			)
		linked_list.print_list()
		print('\nDelete head'			)
		linked_list.delete_head()
		print('Delete tail'			)
		linked_list.delete_tail()
		print('\nPrint list:'			)
		linked_list.print_list()
		print('\nReverse linked list'			)
		linked_list.reverse()
		print('\nPrint list:'			)
		linked_list.print_list()
		print('\nString representation of linked list:'			)
		print(UpperCamelCase_			)
		print('\nReading/changing Node data using indexing:'			)
		print(f"""Element at Position 1: {linked_list[1]}"""			)
		snake_case__	     =input('Enter New Value: '			).strip()
		print('New list:'			)
		print(UpperCamelCase_			)
		print(f"""length of linked_list is : {len(UpperCamelCase_			)}"""			)


if __name__ == "__main__":
			main()









'''simple docstring'''

import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

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 (
			    MODEL_FOR_PRETRAINING_MAPPING,
			    AlbertForMaskedLM,
			    AlbertForMultipleChoice,
			    AlbertForPreTraining,
			    AlbertForQuestionAnswering,
			    AlbertForSequenceClassification,
			    AlbertForTokenClassification,
			    AlbertModel,
			)
			from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST

class 							a__:






			def __init__(     self					,   _UpperCAmelCase					,   _UpperCAmelCase=13					,   _UpperCAmelCase=7					,   _UpperCAmelCase=True					,   _UpperCAmelCase=True					,   _UpperCAmelCase=True					,   _UpperCAmelCase=True					,   _UpperCAmelCase=99					,   _UpperCAmelCase=16					,   _UpperCAmelCase=36					,   _UpperCAmelCase=6					,   _UpperCAmelCase=6					,   _UpperCAmelCase=6					,   _UpperCAmelCase=37					,   _UpperCAmelCase="gelu"					,   _UpperCAmelCase=0.1					,   _UpperCAmelCase=0.1					,   _UpperCAmelCase=512					,   _UpperCAmelCase=16					,   _UpperCAmelCase=2					,   _UpperCAmelCase=0.02					,   _UpperCAmelCase=3					,   _UpperCAmelCase=4					,   _UpperCAmelCase=None					,   )							->							Dict:
					snake_case__	     =parent
					snake_case__	     =batch_size
					snake_case__	     =seq_length
					snake_case__	     =is_training
					snake_case__	     =use_input_mask
					snake_case__	     =use_token_type_ids
					snake_case__	     =use_labels
					snake_case__	     =vocab_size
					snake_case__	     =embedding_size
					snake_case__	     =hidden_size
					snake_case__	     =num_hidden_layers
					snake_case__	     =num_hidden_groups
					snake_case__	     =num_attention_heads
					snake_case__	     =intermediate_size
					snake_case__	     =hidden_act
					snake_case__	     =hidden_dropout_prob
					snake_case__	     =attention_probs_dropout_prob
					snake_case__	     =max_position_embeddings
					snake_case__	     =type_vocab_size
					snake_case__	     =type_sequence_label_size
					snake_case__	     =initializer_range
					snake_case__	     =num_labels
					snake_case__	     =num_choices
					snake_case__	     =scope






			def 						_lowercase  (     self						)							->							Tuple:
					snake_case__	     =ids_tensor([self.batch_size, self.seq_length]					,   self.vocab_size						)

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

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

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

					snake_case__	     =self.get_config()

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






			def 						_lowercase  (     self						)							->							Union[str, Any]:
					return AlbertConfig(
					    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					,   initializer_range=self.initializer_range					,   num_hidden_groups=self.num_hidden_groups					,   )






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							List[str]:
					snake_case__	     =AlbertModel(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase						)
					snake_case__	     =model(_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase						)
					snake_case__	     =model(_UpperCAmelCase						)
					self.parent.assertEqual(result.last_hidden_state.shape					,   (self.batch_size, self.seq_length, self.hidden_size)						)
					self.parent.assertEqual(result.pooler_output.shape					,   (self.batch_size, self.hidden_size)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Dict:
					snake_case__	     =AlbertForPreTraining(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(
					    _UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase					,   labels=_UpperCAmelCase					,   sentence_order_label=_UpperCAmelCase					,   )
					self.parent.assertEqual(result.prediction_logits.shape					,   (self.batch_size, self.seq_length, self.vocab_size)						)
					self.parent.assertEqual(result.sop_logits.shape					,   (self.batch_size, config.num_labels)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							List[str]:
					snake_case__	     =AlbertForMaskedLM(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase					,   labels=_UpperCAmelCase						)
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.vocab_size)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							List[str]:
					snake_case__	     =AlbertForQuestionAnswering(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(
					    _UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase					,   start_positions=_UpperCAmelCase					,   end_positions=_UpperCAmelCase					,   )
					self.parent.assertEqual(result.start_logits.shape					,   (self.batch_size, self.seq_length)						)
					self.parent.assertEqual(result.end_logits.shape					,   (self.batch_size, self.seq_length)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Optional[int]:
					snake_case__	     =self.num_labels
					snake_case__	     =AlbertForSequenceClassification(_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase					,   labels=_UpperCAmelCase						)
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.num_labels)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Any:
					snake_case__	     =self.num_labels
					snake_case__	     =AlbertForTokenClassification(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =model(_UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase					,   labels=_UpperCAmelCase						)
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.seq_length, self.num_labels)						)






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase						)							->							Dict:
					snake_case__	     =self.num_choices
					snake_case__	     =AlbertForMultipleChoice(config=_UpperCAmelCase						)
					model.to(_UpperCAmelCase						)
					model.eval()
					snake_case__	     =input_ids.unsqueeze(1						).expand(-1					,   self.num_choices					,   -1						).contiguous()
					snake_case__	     =token_type_ids.unsqueeze(1						).expand(-1					,   self.num_choices					,   -1						).contiguous()
					snake_case__	     =input_mask.unsqueeze(1						).expand(-1					,   self.num_choices					,   -1						).contiguous()
					snake_case__	     =model(
					    _UpperCAmelCase					,   attention_mask=_UpperCAmelCase					,   token_type_ids=_UpperCAmelCase					,   labels=_UpperCAmelCase					,   )
					self.parent.assertEqual(result.logits.shape					,   (self.batch_size, self.num_choices)						)






			def 						_lowercase  (     self						)							->							List[Any]:
					snake_case__	     =self.prepare_config_and_inputs()
					(
					    (
					    snake_case__
					)     ,	(
					    snake_case__
					)     ,	(
					    snake_case__
					)     ,	(
					    snake_case__
					)     ,	(
					    snake_case__
					)     ,	(
					    snake_case__
					)     ,	(
					    snake_case__
					)     ,	
					)	     =config_and_inputs
					snake_case__	     ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
					return config, inputs_dict





@require_torch
class 							a__( snake_case__   ,      snake_case__   ,      unittest.TestCase     ):
			a_	: Optional[int]									=      (
			    (
			        AlbertModel,
			        AlbertForPreTraining,
			        AlbertForMaskedLM,
			        AlbertForMultipleChoice,
			        AlbertForSequenceClassification,
			        AlbertForTokenClassification,
			        AlbertForQuestionAnswering,
			    )
			    if is_torch_available()
			    else ()
			)
			a_	: List[str]									=      (
			    {
			        '''feature-extraction''': AlbertModel,
			        '''fill-mask''': AlbertForMaskedLM,
			        '''question-answering''': AlbertForQuestionAnswering,
			        '''text-classification''': AlbertForSequenceClassification,
			        '''token-classification''': AlbertForTokenClassification,
			        '''zero-shot''': AlbertForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			a_	: int									=      True






			def 						_lowercase  (     self					,   _UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase=False						)							->							Any:
					snake_case__	     =super()._prepare_for_class(_UpperCAmelCase					,   _UpperCAmelCase					,   return_labels=_UpperCAmelCase						)

					if return_labels:
							if model_class in get_values(_UpperCAmelCase						):
									snake_case__	     =torch.zeros(
									    (self.model_tester.batch_size, self.model_tester.seq_length)					,   dtype=torch.long					,   device=_UpperCAmelCase						)
									snake_case__	     =torch.zeros(
									    self.model_tester.batch_size					,   dtype=torch.long					,   device=_UpperCAmelCase						)
					return inputs_dict






			def 						_lowercase  (     self						)							->							int:
					snake_case__	     =AlbertModelTester(self						)
					snake_case__	     =ConfigTester(self					,   config_class=_UpperCAmelCase					,   hidden_size=37						)






			def 						_lowercase  (     self						)							->							Dict:
					self.config_tester.run_common_tests()






			def 						_lowercase  (     self						)							->							str:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_model(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Optional[int]:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_pretraining(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Optional[Any]:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_lm(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Tuple:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_multiple_choice(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							List[str]:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_question_answering(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							Optional[int]:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_sequence_classification(*_UpperCAmelCase						)






			def 						_lowercase  (     self						)							->							List[str]:
					snake_case__	     =self.model_tester.prepare_config_and_inputs()
					for type in ["absolute", "relative_key", "relative_key_query"]:
							snake_case__	     =type
							self.model_tester.create_and_check_model(*_UpperCAmelCase						)






			@slow
			def 						_lowercase  (     self						)							->							Union[str, Any]:
					for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							snake_case__	     =AlbertModel.from_pretrained(_UpperCAmelCase						)
							self.assertIsNotNone(_UpperCAmelCase						)





@require_torch
class 							a__( unittest.TestCase     ):






			@slow
			def 						_lowercase  (     self						)							->							str:
					snake_case__	     =AlbertModel.from_pretrained('albert-base-v2'						)
					snake_case__	     =torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]						)
					snake_case__	     =torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]						)
					with torch.no_grad():
							snake_case__	     =model(_UpperCAmelCase					,   attention_mask=_UpperCAmelCase						)[0]
					snake_case__	     =torch.Size((1, 11, 768)						)
					self.assertEqual(output.shape					,   _UpperCAmelCase						)
					snake_case__	     =torch.tensor(
					    [[[-0.6_513, 1.5_035, -0.2_766], [-0.6_515, 1.5_046, -0.2_780], [-0.6_512, 1.5_049, -0.2_784]]]						)

					self.assertTrue(torch.allclose(output[:, 1:4, 1:4]					,   _UpperCAmelCase					,   atol=1E-4						)						)




