





import heapq
import sys

import numpy as np

lowerCamelCase			:					int         =	tuple[int, int]



class 							_UpperCamelCase			:


      def __init__(	self	)->	Union[str, Any]:
           __lowerCAmelCase								=					[]
           __lowerCAmelCase								=					set()


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           if not self.empty():
                return self.elements[0][0]
           else:
                return float("inf"	)


      def  __UpperCAmelCase		(	self	)->	Optional[int]:
           return len(self.elements	) == 0


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase	)->	Tuple:
           if item not in self.set:
                heapq.heappush(self.elements					,						(priority, item)	)
                self.set.add(__UpperCamelCase	)
           else:
                # update
                # print("update", item)
                __lowerCAmelCase								=					[]
                ((__lowerCAmelCase)			, (__lowerCAmelCase))								=					heapq.heappop(self.elements	)
                while x != item:
                     temp.append((pri, x)	)
                     ((__lowerCAmelCase)			, (__lowerCAmelCase))								=					heapq.heappop(self.elements	)
                temp.append((priority, item)	)
                for pro, xxx in temp:
                     heapq.heappush(self.elements					,						(pro, xxx)	)


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase	)->	Tuple:
           if item in self.set:
                self.set.remove(__UpperCamelCase	)
                __lowerCAmelCase								=					[]
                ((__lowerCAmelCase)			, (__lowerCAmelCase))								=					heapq.heappop(self.elements	)
                while x != item:
                     temp.append((pro, x)	)
                     ((__lowerCAmelCase)			, (__lowerCAmelCase))								=					heapq.heappop(self.elements	)
                for prito, yyy in temp:
                     heapq.heappush(self.elements					,						(prito, yyy)	)


      def  __UpperCAmelCase		(	self	)->	str:
           return self.elements[0][1]


      def  __UpperCAmelCase		(	self	)->	Optional[Any]:
           ((__lowerCAmelCase)			, (__lowerCAmelCase))								=					heapq.heappop(self.elements	)
           self.set.remove(__UpperCamelCase	)
           return (priority, item)





def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     # euclidean distance
     __lowerCAmelCase								=					np.array(__snake_case       )
     __lowerCAmelCase								=					np.array(__snake_case       )
     return np.linalg.norm(a - b       )





def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     # integer division by time variable
     return consistent_heuristic(__snake_case					, __snake_case       ) // t





def       __lowerCAmelCase      (						__snake_case					, __snake_case       ):
     # manhattan distance
     return abs(p[0] - goal[0]       ) + abs(p[1] - goal[1]       )





def       __lowerCAmelCase      (						__snake_case					, __snake_case					, __snake_case					, __snake_case       ):
     __lowerCAmelCase								=					g_function[start] + Wa * heuristics[i](__snake_case					, __snake_case       )
     return ans





def       __lowerCAmelCase      (						__snake_case					, __snake_case					, __snake_case       ):
     __lowerCAmelCase								=					np.chararray((n, n)       )
     for i in range(__snake_case       ):
          for j in range(__snake_case       ):
               __lowerCAmelCase								=					"*"

     for i in range(__snake_case       ):
          for j in range(__snake_case       ):
               if (j, (n - 1) - i) in blocks:
                    __lowerCAmelCase								=					"#"

     __lowerCAmelCase								=					"-"
     __lowerCAmelCase								=					back_pointer[goal]
     while x != start:
          ((__lowerCAmelCase)			, (__lowerCAmelCase))								=					x
          # print(x)
          __lowerCAmelCase								=					"-"
          __lowerCAmelCase								=					back_pointer[x]
     __lowerCAmelCase								=					"-"

     for i in range(__snake_case       ):
          for j in range(__snake_case       ):
               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								=					back_pointer[goal]
     while x != start:
          print(__snake_case					, end=" "       )
          __lowerCAmelCase								=					back_pointer[x]
     print(__snake_case       )
     sys.exit()





def       __lowerCAmelCase      (						__snake_case       ):
     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       __lowerCAmelCase      (						__snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, ):
     for itera in range(__snake_case       ):
          open_list[itera].remove_element(__snake_case       )
     # print("s", s)
     # print("j", j)
     ((__lowerCAmelCase)			, (__lowerCAmelCase))								=					s
     __lowerCAmelCase								=					(x - 1, y)
     __lowerCAmelCase								=					(x + 1, y)
     __lowerCAmelCase								=					(x, y + 1)
     __lowerCAmelCase								=					(x, y - 1)

     for neighbours in [left, right, up, down]:
          if neighbours not in blocks:
               if valid(__snake_case       ) and neighbours not in visited:
                    # print("neighbour", neighbours)
                    visited.add(__snake_case       )
                    __lowerCAmelCase								=					-1
                    __lowerCAmelCase								=					float("inf"       )

               if valid(__snake_case       ) and g_function[neighbours] > g_function[s] + 1:
                    __lowerCAmelCase								=					g_function[s] + 1
                    __lowerCAmelCase								=					s
                    if neighbours not in close_list_anchor:
                         open_list[0].put(__snake_case					, key(__snake_case					, 0					, __snake_case					, __snake_case       )       )
                         if neighbours not in close_list_inad:
                              for var in range(1					, __snake_case       ):
                                   if key(__snake_case					, __snake_case					, __snake_case					, __snake_case       ) <= Wa * key(
                                       __snake_case					, 0					, __snake_case					, __snake_case       ):
                                        open_list[j].put(
                                            __snake_case					, key(__snake_case					, __snake_case					, __snake_case					, __snake_case       )       )





def       __lowerCAmelCase      (						):
     __lowerCAmelCase								=					[]
     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


lowerCamelCase			:					Optional[Any]         =	{0: consistent_heuristic, 1: heuristic_a, 2: heuristic_a}

lowerCamelCase			:					str         =	[
    (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),
]
lowerCamelCase			:					List[str]         =	make_common_ground()


lowerCamelCase			:					Any         =	blocks_blk
# hyper parameters
lowerCamelCase			:					Optional[int]         =	1
lowerCamelCase			:					Any         =	1
lowerCamelCase			:					Optional[Any]         =	20
lowerCamelCase			:					Dict         =	3  # one consistent and two other inconsistent

# start and end destination
lowerCamelCase			:					Any         =	(0, 0)
lowerCamelCase			:					Optional[int]         =	(n - 1, n - 1)

lowerCamelCase			:					Optional[int]         =	1





def       __lowerCAmelCase      (						__snake_case					, __snake_case					, __snake_case       ):
     __lowerCAmelCase								=					{start: 0, goal: float("inf"       )}
     __lowerCAmelCase								=					{start: -1, goal: -1}
     __lowerCAmelCase								=					[]
     __lowerCAmelCase								=					set()

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

     __lowerCAmelCase								=					[]
     __lowerCAmelCase								=					[]
     while open_list[0].minkey() < float("inf"       ):
          for i in range(1					, __snake_case       ):
               # 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(__snake_case					, __snake_case					, __snake_case       )
                    else:
                         __lowerCAmelCase			, __lowerCAmelCase								=					open_list[i].top_show()
                         visited.add(__snake_case       )
                         expand_state(
                             __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, )
                         close_list_inad.append(__snake_case       )
               else:
                    if g_function[goal] <= open_list[0].minkey():
                         if g_function[goal] < float("inf"       ):
                              do_something(__snake_case					, __snake_case					, __snake_case       )
                    else:
                         __lowerCAmelCase								=					open_list[0].top_show()
                         visited.add(__snake_case       )
                         expand_state(
                             __snake_case					, 0					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, __snake_case					, )
                         close_list_anchor.append(__snake_case       )
     print("No path found to goal"       )
     print()
     for i in range(n - 1					, -1					, -1       ):
          for j in range(__snake_case       ):
               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)














from collections import OrderedDict
from typing import Any, Mapping, Optional

from ... import PreTrainedTokenizer
from ...configuration_utils import PretrainedConfig
from ...file_utils import TensorType, is_torch_available
from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
from ...onnx.utils import compute_effective_axis_dimension
from ...utils import logging


lowerCamelCase			:					List[Any]         =	logging.get_logger(__name__)

lowerCamelCase			:					Union[str, Any]         =	{
    '''facebook/blenderbot_small-90M''': '''https://huggingface.co/facebook/blenderbot_small-90M/resolve/main/config.json''',
    # See all BlenderbotSmall models at https://huggingface.co/models?filter=blenderbot_small
}



class 							_UpperCamelCase			(a_			):
      snake_case_  =							"""blenderbot-small"""
      snake_case_  =							["""past_key_values"""]
      snake_case_  =							{"""num_attention_heads""": """encoder_attention_heads""", """hidden_size""": """d_model"""}


      def __init__(	self					,						__UpperCamelCase=5_0_2_6_5					,						__UpperCamelCase=5_1_2					,						__UpperCamelCase=8					,						__UpperCamelCase=2_0_4_8					,						__UpperCamelCase=1_6					,						__UpperCamelCase=8					,						__UpperCamelCase=2_0_4_8					,						__UpperCamelCase=1_6					,						__UpperCamelCase=0.0					,						__UpperCamelCase=0.0					,						__UpperCamelCase=True					,						__UpperCamelCase=True					,						__UpperCamelCase="gelu"					,						__UpperCamelCase=5_1_2					,						__UpperCamelCase=0.1					,						__UpperCamelCase=0.0					,						__UpperCamelCase=0.0					,						__UpperCamelCase=0.0_2					,						__UpperCamelCase=1					,						__UpperCamelCase=False					,						__UpperCamelCase=0					,						__UpperCamelCase=1					,						__UpperCamelCase=2					,						__UpperCamelCase=2					,						**__UpperCamelCase					,						)->	Any:
           __lowerCAmelCase								=					vocab_size
           __lowerCAmelCase								=					max_position_embeddings
           __lowerCAmelCase								=					d_model
           __lowerCAmelCase								=					encoder_ffn_dim
           __lowerCAmelCase								=					encoder_layers
           __lowerCAmelCase								=					encoder_attention_heads
           __lowerCAmelCase								=					decoder_ffn_dim
           __lowerCAmelCase								=					decoder_layers
           __lowerCAmelCase								=					decoder_attention_heads
           __lowerCAmelCase								=					dropout
           __lowerCAmelCase								=					attention_dropout
           __lowerCAmelCase								=					activation_dropout
           __lowerCAmelCase								=					activation_function
           __lowerCAmelCase								=					init_std
           __lowerCAmelCase								=					encoder_layerdrop
           __lowerCAmelCase								=					decoder_layerdrop
           __lowerCAmelCase								=					use_cache
           __lowerCAmelCase								=					encoder_layers
           __lowerCAmelCase								=					scale_embedding  # scale factor will be sqrt(d_model) if True

           super().__init__(
               pad_token_id=__UpperCamelCase					,						bos_token_id=__UpperCamelCase					,						eos_token_id=__UpperCamelCase					,						is_encoder_decoder=__UpperCamelCase					,						decoder_start_token_id=__UpperCamelCase					,						forced_eos_token_id=__UpperCamelCase					,						**__UpperCamelCase					,						)



class 							_UpperCamelCase			(a_			):


      @property
      def  __UpperCAmelCase		(	self	)->	Mapping[str, Mapping[int, str]]:
           if self.task in ["default", "seq2seq-lm"]:
                __lowerCAmelCase								=					OrderedDict(
                    [
                        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                    ]	)

                if self.use_past:
                     __lowerCAmelCase								=					{0: "batch"}
                     __lowerCAmelCase								=					{0: "batch", 1: "past_decoder_sequence + sequence"}
                else:
                     __lowerCAmelCase								=					{0: "batch", 1: "decoder_sequence"}
                     __lowerCAmelCase								=					{0: "batch", 1: "decoder_sequence"}

                if self.use_past:
                     self.fill_with_past_key_values_(__UpperCamelCase					,						direction="inputs"	)
           elif self.task == "causal-lm":
                # TODO: figure this case out.
                __lowerCAmelCase								=					OrderedDict(
                    [
                        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                    ]	)
                if self.use_past:
                     __lowerCAmelCase			, __lowerCAmelCase								=					self.num_layers
                     for i in range(__UpperCamelCase	):
                          __lowerCAmelCase								=					{0: "batch", 2: "past_sequence + sequence"}
                          __lowerCAmelCase								=					{0: "batch", 2: "past_sequence + sequence"}
           else:
                __lowerCAmelCase								=					OrderedDict(
                    [
                        ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                        ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                        ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
                        ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
                    ]	)

           return common_inputs


      @property
      def  __UpperCAmelCase		(	self	)->	Mapping[str, Mapping[int, str]]:
           if self.task in ["default", "seq2seq-lm"]:
                __lowerCAmelCase								=					super().outputs
           else:
                __lowerCAmelCase								=					super(__UpperCamelCase					,						self	).outputs
                if self.use_past:
                     __lowerCAmelCase			, __lowerCAmelCase								=					self.num_layers
                     for i in range(__UpperCamelCase	):
                          __lowerCAmelCase								=					{0: "batch", 2: "past_sequence + sequence"}
                          __lowerCAmelCase								=					{0: "batch", 2: "past_sequence + sequence"}
           return common_outputs


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase = -1					,						__UpperCamelCase = -1					,						__UpperCamelCase = False					,						__UpperCamelCase = None					,						)->	Mapping[str, Any]:
           __lowerCAmelCase								=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
               __UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)

           # Generate decoder inputs
           __lowerCAmelCase								=					seq_length if not self.use_past else 1
           __lowerCAmelCase								=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
               __UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)
           __lowerCAmelCase								=					{F"""decoder_{name}""": tensor for name, tensor in decoder_inputs.items()}
           __lowerCAmelCase								=					dict(**__UpperCamelCase					,						**__UpperCamelCase	)

           if self.use_past:
                if not is_torch_available():
                     raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."	)
                else:
                     import torch
                __lowerCAmelCase			, __lowerCAmelCase								=					common_inputs["input_ids"].shape
                __lowerCAmelCase								=					common_inputs["decoder_input_ids"].shape[1]
                __lowerCAmelCase			, __lowerCAmelCase								=					self.num_attention_heads
                __lowerCAmelCase								=					(
                    batch,
                    num_encoder_attention_heads,
                    encoder_seq_length,
                    self._config.hidden_size // num_encoder_attention_heads,
                )
                __lowerCAmelCase								=					decoder_seq_length + 3
                __lowerCAmelCase								=					(
                    batch,
                    num_decoder_attention_heads,
                    decoder_past_length,
                    self._config.hidden_size // num_decoder_attention_heads,
                )

                __lowerCAmelCase								=					torch.cat(
                    [common_inputs["decoder_attention_mask"], torch.ones(__UpperCamelCase					,						__UpperCamelCase	)]					,						dim=1	)

                __lowerCAmelCase								=					[]
                # If the number of encoder and decoder layers are present in the model configuration, both are considered
                __lowerCAmelCase			, __lowerCAmelCase								=					self.num_layers
                __lowerCAmelCase								=					min(__UpperCamelCase					,						__UpperCamelCase	)
                __lowerCAmelCase								=					max(__UpperCamelCase					,						__UpperCamelCase	) - min_num_layers
                __lowerCAmelCase								=					"encoder" if num_encoder_layers > num_decoder_layers else "decoder"

                for _ in range(__UpperCamelCase	):
                     common_inputs["past_key_values"].append(
                         (
                             torch.zeros(__UpperCamelCase	),
                             torch.zeros(__UpperCamelCase	),
                             torch.zeros(__UpperCamelCase	),
                             torch.zeros(__UpperCamelCase	),
                         )	)
                # TODO: test this.
                __lowerCAmelCase								=					encoder_shape if remaining_side_name == "encoder" else decoder_shape
                for _ in range(__UpperCamelCase					,						__UpperCamelCase	):
                     common_inputs["past_key_values"].append((torch.zeros(__UpperCamelCase	), torch.zeros(__UpperCamelCase	))	)
           return common_inputs


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase = -1					,						__UpperCamelCase = -1					,						__UpperCamelCase = False					,						__UpperCamelCase = None					,						)->	Mapping[str, Any]:
           __lowerCAmelCase								=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
               __UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)

           if self.use_past:
                if not is_torch_available():
                     raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."	)
                else:
                     import torch
                __lowerCAmelCase			, __lowerCAmelCase								=					common_inputs["input_ids"].shape
                # Not using the same length for past_key_values
                __lowerCAmelCase								=					seqlen + 2
                __lowerCAmelCase			, __lowerCAmelCase								=					self.num_layers
                __lowerCAmelCase			, __lowerCAmelCase								=					self.num_attention_heads
                __lowerCAmelCase								=					(
                    batch,
                    num_encoder_attention_heads,
                    past_key_values_length,
                    self._config.hidden_size // num_encoder_attention_heads,
                )

                __lowerCAmelCase								=					common_inputs["attention_mask"].dtype
                __lowerCAmelCase								=					torch.cat(
                    [common_inputs["attention_mask"], torch.ones(__UpperCamelCase					,						__UpperCamelCase					,						dtype=__UpperCamelCase	)]					,						dim=1	)
                __lowerCAmelCase								=					[
                    (torch.zeros(__UpperCamelCase	), torch.zeros(__UpperCamelCase	)) for _ in range(__UpperCamelCase	)
                ]
           return common_inputs


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase = -1					,						__UpperCamelCase = -1					,						__UpperCamelCase = False					,						__UpperCamelCase = None					,						)->	Mapping[str, Any]:
           # Copied from OnnxConfig.generate_dummy_inputs
           # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
           # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
           __lowerCAmelCase								=					compute_effective_axis_dimension(
               __UpperCamelCase					,						fixed_dimension=OnnxConfig.default_fixed_batch					,						num_token_to_add=0	)

           # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
           __lowerCAmelCase								=					tokenizer.num_special_tokens_to_add(__UpperCamelCase	)
           __lowerCAmelCase								=					compute_effective_axis_dimension(
               __UpperCamelCase					,						fixed_dimension=OnnxConfig.default_fixed_sequence					,						num_token_to_add=__UpperCamelCase	)

           # Generate dummy inputs according to compute batch and sequence
           __lowerCAmelCase								=					[" ".join([tokenizer.unk_token]	) * seq_length] * batch_size
           __lowerCAmelCase								=					dict(tokenizer(__UpperCamelCase					,						return_tensors=__UpperCamelCase	)	)
           return common_inputs


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase = -1					,						__UpperCamelCase = -1					,						__UpperCamelCase = False					,						__UpperCamelCase = None					,						)->	Mapping[str, Any]:
           if self.task in ["default", "seq2seq-lm"]:
                __lowerCAmelCase								=					self._generate_dummy_inputs_for_default_and_seqaseq_lm(
                    __UpperCamelCase					,						batch_size=__UpperCamelCase					,						seq_length=__UpperCamelCase					,						is_pair=__UpperCamelCase					,						framework=__UpperCamelCase	)

           elif self.task == "causal-lm":
                __lowerCAmelCase								=					self._generate_dummy_inputs_for_causal_lm(
                    __UpperCamelCase					,						batch_size=__UpperCamelCase					,						seq_length=__UpperCamelCase					,						is_pair=__UpperCamelCase					,						framework=__UpperCamelCase	)
           else:
                __lowerCAmelCase								=					self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
                    __UpperCamelCase					,						batch_size=__UpperCamelCase					,						seq_length=__UpperCamelCase					,						is_pair=__UpperCamelCase					,						framework=__UpperCamelCase	)

           return common_inputs


      def  __UpperCAmelCase		(	self					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)->	List[Any]:
           if self.task in ["default", "seq2seq-lm"]:
                __lowerCAmelCase								=					super()._flatten_past_key_values_(__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)
           else:
                __lowerCAmelCase								=					super(__UpperCamelCase					,						self	)._flatten_past_key_values_(
                    __UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase					,						__UpperCamelCase	)






