




"""simple docstring"""
import heapq
import sys

import numpy as np

a_				:    Union[str, Any]										=     tuple[int, int]

class __lowercase:




					'''simple docstring'''


					def __init__(    self     ):
								__lowerCamelCase					:	Tuple	       =				[]
								__lowerCamelCase					:	Tuple	       =				set()
					def     snake_case_				(    self     ):
								if not self.empty():
											return self.elements[0][0]
								else:
											return float('inf'     )
					def     snake_case_				(    self     ):
								return len(self.elements     ) == 0
					def     snake_case_				(    self						,	__a						,	__a     ):
								if item not in self.set:
											heapq.heappush(self.elements						,	(priority, item)     )
											self.set.add(__a     )
								else:
											# update
											# print("update", item)
											__lowerCamelCase					:	List[Any]	       =				[]
											((__lowerCamelCase)       ,      (__lowerCamelCase))					:	Dict	       =				heapq.heappop(self.elements     )
											while x != item:
														temp.append((pri, x)     )
														((__lowerCamelCase)       ,      (__lowerCamelCase))					:	Any	       =				heapq.heappop(self.elements     )
											temp.append((priority, item)     )
											for pro, xxx in temp:
														heapq.heappush(self.elements						,	(pro, xxx)     )
					def     snake_case_				(    self						,	__a     ):
								if item in self.set:
											self.set.remove(__a     )
											__lowerCamelCase					:	Any	       =				[]
											((__lowerCamelCase)       ,      (__lowerCamelCase))					:	Optional[int]	       =				heapq.heappop(self.elements     )
											while x != item:
														temp.append((pro, x)     )
														((__lowerCamelCase)       ,      (__lowerCamelCase))					:	Tuple	       =				heapq.heappop(self.elements     )
											for prito, yyy in temp:
														heapq.heappush(self.elements						,	(prito, yyy)     )
					def     snake_case_				(    self     ):
								return self.elements[0][1]





					def     snake_case_				(    self     ):
								((__lowerCamelCase)       ,      (__lowerCamelCase))					:	Dict	       =				heapq.heappop(self.elements     )
								self.set.remove(__a     )
								return (priority, item)





def 						UpperCAmelCase				(			A__:    TPos							,				A__:    TPos     )  ->     Optional[Any]:
			# euclidean distance
			__lowerCamelCase					:	Any	       =				np.array(A__     )
			__lowerCamelCase					:	str	       =				np.array(A__     )
			return np.linalg.norm(a - b     )





def 						UpperCAmelCase				(			A__:    TPos							,				A__:    TPos     )  ->     int:
			# integer division by time variable
			return consistent_heuristic(A__							,				A__     ) // t





def 						UpperCAmelCase				(			A__:    TPos							,				A__:    TPos     )  ->     List[Any]:
			# manhattan distance
			return abs(p[0] - goal[0]     ) + abs(p[1] - goal[1]     )





def 						UpperCAmelCase				(			A__:    TPos							,				A__:    int							,				A__:    TPos							,				A__:    dict[TPos, float]     )  ->     Tuple:
			__lowerCamelCase					:	str	       =				g_function[start] + Wa * heuristics[i](A__							,				A__     )
			return ans





def 						UpperCAmelCase				(			A__:    Tuple							,				A__:    Optional[Any]							,				A__:    List[str]     )  ->     Union[str, Any]:
			__lowerCamelCase					:	Tuple	       =				np.chararray((n, n)     )
			for i in range(A__     ):
						for j in range(A__     ):
									__lowerCamelCase					:	List[Any]	       =				'*'

			for i in range(A__     ):
						for j in range(A__     ):
									if (j, (n - 1) - i) in blocks:
												__lowerCamelCase					:	Tuple	       =				'#'

			__lowerCamelCase					:	str	       =				'-'
			__lowerCamelCase					:	Tuple	       =				back_pointer[goal]
			while x != start:
						((__lowerCamelCase)       ,      (__lowerCamelCase))					:	str	       =				x
						# print(x)
						__lowerCamelCase					:	Any	       =				'-'
						__lowerCamelCase					:	Dict	       =				back_pointer[x]
			__lowerCamelCase					:	List[str]	       =				'-'

			for i in range(A__     ):
						for j in range(A__     ):
									if (i, j) == (0, n - 1):
												print(grid[i][j]							,				end=' '     )
												print('<-- End position'							,				end=' '     )
									else:
												print(grid[i][j]							,				end=' '     )
						print()
			print('^'     )
			print('Start position'     )
			print()
			print('# is an obstacle'     )
			print('- is the path taken by algorithm'     )
			print('PATH TAKEN BY THE ALGORITHM IS:-'     )
			__lowerCamelCase					:	List[Any]	       =				back_pointer[goal]
			while x != start:
						print(A__							,				end=' '     )
						__lowerCamelCase					:	List[str]	       =				back_pointer[x]
			print(A__     )
			sys.exit()





def 						UpperCAmelCase				(			A__:    TPos     )  ->     Tuple:
			if p[0] < 0 or p[0] > n - 1:
						return False
			if p[1] < 0 or p[1] > n - 1:
						return False
			return True





def 						UpperCAmelCase				(			A__:    Tuple							,				A__:    int							,				A__:    str							,				A__:    Optional[Any]							,				A__:    List[str]							,				A__:    int							,				A__:    List[Any]							,				A__:    Union[str, Any]							,				)  ->     int:
			for itera in range(A__     ):
						open_list[itera].remove_element(A__     )
			# print("s", s)
			# print("j", j)
			((__lowerCamelCase)       ,      (__lowerCamelCase))					:	Optional[Any]	       =				s
			__lowerCamelCase					:	str	       =				(x - 1, y)
			__lowerCamelCase					:	int	       =				(x + 1, y)
			__lowerCamelCase					:	Dict	       =				(x, y + 1)
			__lowerCamelCase					:	List[Any]	       =				(x, y - 1)

			for neighbours in [left, right, up, down]:
						if neighbours not in blocks:
									if valid(A__     ) and neighbours not in visited:
												# print("neighbour", neighbours)
												visited.add(A__     )
												__lowerCamelCase					:	List[str]	       =				-1
												__lowerCamelCase					:	List[Any]	       =				float('inf'     )

									if valid(A__     ) and g_function[neighbours] > g_function[s] + 1:
												__lowerCamelCase					:	Union[str, Any]	       =				g_function[s] + 1
												__lowerCamelCase					:	Optional[int]	       =				s
												if neighbours not in close_list_anchor:
															open_list[0].put(A__							,				key(A__							,				0							,				A__							,				A__     )     )
															if neighbours not in close_list_inad:
																		for var in range(1							,				A__     ):
																					if key(A__							,				A__							,				A__							,				A__     ) <= Wa * key(
																					    A__							,				0							,				A__							,				A__     ):
																								open_list[j].put(
																								    A__							,				key(A__							,				A__							,				A__							,				A__     )     )





def 						UpperCAmelCase				(			)  ->     int:
			__lowerCamelCase					:	Tuple	       =				[]
			for x in range(1							,				5     ):
						for y in range(1							,				6     ):
									some_list.append((x, y)     )

			for x in range(15							,				20     ):
						some_list.append((x, 17)     )

			for x in range(10							,				19     ):
						for y in range(1							,				15     ):
									some_list.append((x, y)     )

    # L block
			for x in range(1							,				4     ):
						for y in range(12							,				19     ):
									some_list.append((x, y)     )
			for x in range(3							,				13     ):
						for y in range(16							,				19     ):
									some_list.append((x, y)     )
			return some_list


a_				:    Optional[int]										=     {0: consistent_heuristic, 1: heuristic_a, 2: heuristic_a}

a_				:    Any										=     [
    (0, 1),
    (1, 1),
    (2, 1),
    (3, 1),
    (4, 1),
    (5, 1),
    (6, 1),
    (7, 1),
    (8, 1),
    (9, 1),
    (10, 1),
    (11, 1),
    (12, 1),
    (13, 1),
    (14, 1),
    (15, 1),
    (16, 1),
    (17, 1),
    (18, 1),
    (19, 1),
]
a_				:    Union[str, Any]										=     make_common_ground()


a_				:    Any										=     blocks_blk
# hyper parameters
a_				:    List[str]										=     1
a_				:    Tuple										=     1
a_				:    Union[str, Any]										=     20
a_				:    Optional[int]										=     3  # one consistent and two other inconsistent

# start and end destination
a_				:    List[str]										=     (0, 0)
a_				:    List[str]										=     (n - 1, n - 1)

a_				:    List[str]										=     1





def 						UpperCAmelCase				(			A__:    TPos							,				A__:    TPos							,				A__:    int     )  ->     Union[str, Any]:
			__lowerCamelCase					:	Optional[Any]	       =				{start: 0, goal: float('inf'     )}
			__lowerCamelCase					:	Optional[int]	       =				{start: -1, goal: -1}
			__lowerCamelCase					:	str	       =				[]
			__lowerCamelCase					:	Tuple	       =				set()

			for i in range(A__     ):
						open_list.append(PriorityQueue()     )
						open_list[i].put(A__							,				key(A__							,				A__							,				A__							,				A__     )     )

			__lowerCamelCase					:	list[int]	       =				[]
			__lowerCamelCase					:	list[int]	       =				[]
			while open_list[0].minkey() < float('inf'     ):
						for i in range(1							,				A__     ):
									# print(open_list[0].minkey(), open_list[i].minkey())
									if open_list[i].minkey() <= Wa * open_list[0].minkey():
												global t
												t += 1
												if g_function[goal] <= open_list[i].minkey():
															if g_function[goal] < float('inf'     ):
																		do_something(A__							,				A__							,				A__     )
												else:
															__lowerCamelCase       ,      __lowerCamelCase					:	List[str]	       =				open_list[i].top_show()
															visited.add(A__     )
															expand_state(
															    A__							,				A__							,				A__							,				A__							,				A__							,				A__							,				A__							,				A__							,				)
															close_list_inad.append(A__     )
									else:
												if g_function[goal] <= open_list[0].minkey():
															if g_function[goal] < float('inf'     ):
																		do_something(A__							,				A__							,				A__     )
												else:
															__lowerCamelCase					:	Dict	       =				open_list[0].top_show()
															visited.add(A__     )
															expand_state(
															    A__							,				0							,				A__							,				A__							,				A__							,				A__							,				A__							,				A__							,				)
															close_list_anchor.append(A__     )
			print('No path found to goal'     )
			print()
			for i in range(n - 1							,				-1							,				-1     ):
						for j in range(A__     ):
									if (j, i) in blocks:
												print('#'							,				end=' '     )
									elif (j, i) in back_pointer:
												if (j, i) == (n - 1, n - 1):
															print('*'							,				end=' '     )
												else:
															print('-'							,				end=' '     )
									else:
												print('*'							,				end=' '     )
									if (j, i) == (n - 1, n - 1):
												print('<-- End position'							,				end=' '     )
						print()
			print('^'     )
			print('Start position'     )
			print()
			print('# is an obstacle'     )
			print('- is the path taken by algorithm'     )


if __name__ == "__main__":
					multi_a_star(start, goal, n_heuristic)









"""simple docstring"""
import unittest

from transformers import DebertaVaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
					import torch

					from transformers import (
					    DebertaVaForMaskedLM,
					    DebertaVaForMultipleChoice,
					    DebertaVaForQuestionAnswering,
					    DebertaVaForSequenceClassification,
					    DebertaVaForTokenClassification,
					    DebertaVaModel,
					)
					from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST

class __lowercase(      lowercase__				):




					'''simple docstring'''


					def __init__(    self						,	__a						,	__a=13						,	__a=7						,	__a=True						,	__a=True						,	__a=True						,	__a=True						,	__a=99						,	__a=32						,	__a=5						,	__a=4						,	__a=37						,	__a="gelu"						,	__a=0.1						,	__a=0.1						,	__a=512						,	__a=16						,	__a=2						,	__a=0.02						,	__a=False						,	__a=True						,	__a="None"						,	__a=3						,	__a=4						,	__a=None						,	):
								__lowerCamelCase					:	List[str]	       =				parent
								__lowerCamelCase					:	Dict	       =				batch_size
								__lowerCamelCase					:	str	       =				seq_length
								__lowerCamelCase					:	Optional[int]	       =				is_training
								__lowerCamelCase					:	Dict	       =				use_input_mask
								__lowerCamelCase					:	Dict	       =				use_token_type_ids
								__lowerCamelCase					:	Dict	       =				use_labels
								__lowerCamelCase					:	Optional[Any]	       =				vocab_size
								__lowerCamelCase					:	Any	       =				hidden_size
								__lowerCamelCase					:	List[Any]	       =				num_hidden_layers
								__lowerCamelCase					:	Tuple	       =				num_attention_heads
								__lowerCamelCase					:	Any	       =				intermediate_size
								__lowerCamelCase					:	Optional[Any]	       =				hidden_act
								__lowerCamelCase					:	Any	       =				hidden_dropout_prob
								__lowerCamelCase					:	Optional[Any]	       =				attention_probs_dropout_prob
								__lowerCamelCase					:	List[Any]	       =				max_position_embeddings
								__lowerCamelCase					:	Optional[Any]	       =				type_vocab_size
								__lowerCamelCase					:	Dict	       =				type_sequence_label_size
								__lowerCamelCase					:	Any	       =				initializer_range
								__lowerCamelCase					:	Union[str, Any]	       =				num_labels
								__lowerCamelCase					:	Tuple	       =				num_choices
								__lowerCamelCase					:	str	       =				relative_attention
								__lowerCamelCase					:	Optional[int]	       =				position_biased_input
								__lowerCamelCase					:	int	       =				pos_att_type
								__lowerCamelCase					:	str	       =				scope
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Union[str, Any]	       =				ids_tensor([self.batch_size, self.seq_length]						,	self.vocab_size     )

								__lowerCamelCase					:	int	       =				None
								if self.use_input_mask:
											__lowerCamelCase					:	int	       =				ids_tensor([self.batch_size, self.seq_length]						,	vocab_size=2     )

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

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

								__lowerCamelCase					:	Optional[Any]	       =				self.get_config()

								return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels
					def     snake_case_				(    self     ):
								return DebertaVaConfig(
								    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						,	relative_attention=self.relative_attention						,	position_biased_input=self.position_biased_input						,	pos_att_type=self.pos_att_type						,	)
					def     snake_case_				(    self						,	__a     ):
								self.parent.assertListEqual(list(result.loss.size()     )						,	[]     )
					def     snake_case_				(    self						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a     ):
								__lowerCamelCase					:	int	       =				DebertaVaModel(config=__a     )
								model.to(__a     )
								model.eval()
								__lowerCamelCase					:	str	       =				model(__a						,	attention_mask=__a						,	token_type_ids=__a     )[0]
								__lowerCamelCase					:	str	       =				model(__a						,	token_type_ids=__a     )[0]
								__lowerCamelCase					:	Optional[Any]	       =				model(__a     )[0]

								self.parent.assertListEqual(list(sequence_output.size()     )						,	[self.batch_size, self.seq_length, self.hidden_size]     )
					def     snake_case_				(    self						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a     ):
								__lowerCamelCase					:	List[str]	       =				DebertaVaForMaskedLM(config=__a     )
								model.to(__a     )
								model.eval()
								__lowerCamelCase					:	Union[str, Any]	       =				model(__a						,	attention_mask=__a						,	token_type_ids=__a						,	labels=__a     )

								self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.seq_length, self.vocab_size)     )
					def     snake_case_				(    self						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a     ):
								__lowerCamelCase					:	Optional[int]	       =				self.num_labels
								__lowerCamelCase					:	List[Any]	       =				DebertaVaForSequenceClassification(__a     )
								model.to(__a     )
								model.eval()
								__lowerCamelCase					:	Optional[Any]	       =				model(__a						,	attention_mask=__a						,	token_type_ids=__a						,	labels=__a     )
								self.parent.assertListEqual(list(result.logits.size()     )						,	[self.batch_size, self.num_labels]     )
								self.check_loss_output(__a     )
					def     snake_case_				(    self						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a     ):
								__lowerCamelCase					:	int	       =				self.num_labels
								__lowerCamelCase					:	Dict	       =				DebertaVaForTokenClassification(config=__a     )
								model.to(__a     )
								model.eval()
								__lowerCamelCase					:	int	       =				model(__a						,	attention_mask=__a						,	token_type_ids=__a						,	labels=__a     )
								self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.seq_length, self.num_labels)     )
					def     snake_case_				(    self						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a     ):
								__lowerCamelCase					:	Optional[Any]	       =				DebertaVaForQuestionAnswering(config=__a     )
								model.to(__a     )
								model.eval()
								__lowerCamelCase					:	Any	       =				model(
								    __a						,	attention_mask=__a						,	token_type_ids=__a						,	start_positions=__a						,	end_positions=__a						,	)
								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     snake_case_				(    self						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a						,	__a     ):
								__lowerCamelCase					:	Any	       =				DebertaVaForMultipleChoice(config=__a     )
								model.to(__a     )
								model.eval()
								__lowerCamelCase					:	Union[str, Any]	       =				input_ids.unsqueeze(1     ).expand(-1						,	self.num_choices						,	-1     ).contiguous()
								__lowerCamelCase					:	Optional[int]	       =				token_type_ids.unsqueeze(1     ).expand(-1						,	self.num_choices						,	-1     ).contiguous()
								__lowerCamelCase					:	int	       =				input_mask.unsqueeze(1     ).expand(-1						,	self.num_choices						,	-1     ).contiguous()
								__lowerCamelCase					:	List[Any]	       =				model(
								    __a						,	attention_mask=__a						,	token_type_ids=__a						,	labels=__a						,	)
								self.parent.assertEqual(result.logits.shape						,	(self.batch_size, self.num_choices)     )





					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Any	       =				self.prepare_config_and_inputs()
								(
								    (
								    __lowerCamelCase
								)       ,      (
								    __lowerCamelCase
								)       ,      (
								    __lowerCamelCase
								)       ,      (
								    __lowerCamelCase
								)       ,      (
								    __lowerCamelCase
								)       ,      (
								    __lowerCamelCase
								)       ,      (
								    __lowerCamelCase
								)       ,      
								)					:	List[str]	       =				config_and_inputs
								__lowerCamelCase					:	int	       =				{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
								return config, inputs_dict



@require_torch
class __lowercase(      lowercase__	,	lowercase__	,	unittest.TestCase				):




					'''simple docstring'''


					__a						:						Dict     		= (
					    (
					        DebertaVaModel,
					        DebertaVaForMaskedLM,
					        DebertaVaForSequenceClassification,
					        DebertaVaForTokenClassification,
					        DebertaVaForQuestionAnswering,
					        DebertaVaForMultipleChoice,
					    )
					    if is_torch_available()
					    else ()
					)
					__a						:						Tuple     		= (
					    {
					        'feature-extraction': DebertaVaModel,
					        'fill-mask': DebertaVaForMaskedLM,
					        'question-answering': DebertaVaForQuestionAnswering,
					        'text-classification': DebertaVaForSequenceClassification,
					        'token-classification': DebertaVaForTokenClassification,
					        'zero-shot': DebertaVaForSequenceClassification,
					    }
					    if is_torch_available()
					    else {}
					)

					__a						:						str     		= True
					__a						:						Dict     		= False
					__a						:						Tuple     		= False
					__a						:						Optional[Any]     		= False
					__a						:						List[Any]     		= False
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	List[str]	       =				DebertaVaModelTester(self     )
								__lowerCamelCase					:	Tuple	       =				ConfigTester(self						,	config_class=__a						,	hidden_size=37     )
					def     snake_case_				(    self     ):
								self.config_tester.run_common_tests()
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	int	       =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_model(*__a     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Tuple	       =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_sequence_classification(*__a     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	List[Any]	       =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_masked_lm(*__a     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	str	       =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_question_answering(*__a     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	List[Any]	       =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_token_classification(*__a     )
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Any	       =				self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_deberta_for_multiple_choice(*__a     )





					@slow
					def     snake_case_				(    self     ):
								for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__lowerCamelCase					:	Tuple	       =				DebertaVaModel.from_pretrained(__a     )
											self.assertIsNotNone(__a     )



@require_torch
@require_sentencepiece
@require_tokenizers
class __lowercase(      unittest.TestCase				):




					'''simple docstring'''


					@unittest.skip(reason='Model not available yet'     )
					def     snake_case_				(    self     ):
								pass





					@slow
					def     snake_case_				(    self     ):
								__lowerCamelCase					:	Any	       =				DebertaVaModel.from_pretrained('microsoft/deberta-v2-xlarge'     )

								__lowerCamelCase					:	Any	       =				torch.tensor([[0, 31414, 232, 328, 740, 1140, 12695, 69, 46078, 1588, 2]]     )
								__lowerCamelCase					:	Any	       =				torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]     )
								with torch.no_grad():
											__lowerCamelCase					:	Union[str, Any]	       =				model(__a						,	attention_mask=__a     )[0]
								# compare the actual values for a slice.
								__lowerCamelCase					:	str	       =				torch.tensor(
								    [[[0.2_356, 0.1_948, 0.0_369], [-0.1_063, 0.3_586, -0.5_152], [-0.6_399, -0.0_259, -0.2_525]]]     )
								self.assertTrue(torch.allclose(output[:, 1:4, 1:4]						,	__a						,	atol=1E-4     )						,	f'''{output[:, 1:4, 1:4]}'''     )



