






from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


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

lowerCamelCase       :       Dict        =				{
    '''google/bigbird-roberta-base''': '''https://huggingface.co/google/bigbird-roberta-base/resolve/main/config.json''',
    '''google/bigbird-roberta-large''': '''https://huggingface.co/google/bigbird-roberta-large/resolve/main/config.json''',
    '''google/bigbird-base-trivia-itc''': '''https://huggingface.co/google/bigbird-base-trivia-itc/resolve/main/config.json''',
    # See all BigBird models at https://huggingface.co/models?filter=big_bird
}

class 						lowerCAmelCase   (       __a	):

					'''simple docstring'''

					_A  :	Tuple     =					'''big_bird'''



					def __init__(     self :		Optional[Any]						,   __a :		Any=50358						,   __a :		str=768						,   __a :		List[str]=12						,   __a :		int=12						,   __a :		Optional[Any]=3072						,   __a :		Any="gelu_new"						,   __a :		Optional[Any]=0.1						,   __a :		Tuple=0.1						,   __a :		List[Any]=4096						,   __a :		Dict=2						,   __a :		List[Any]=0.02						,   __a :		List[str]=1E-12						,   __a :		List[Any]=True						,   __a :		Dict=0						,   __a :		str=1						,   __a :		List[Any]=2						,   __a :		Any=66						,   __a :		Optional[Any]="block_sparse"						,   __a :		Any=True						,   __a :		Any=False						,   __a :		List[str]=64						,   __a :		Dict=3						,   __a :		Optional[int]=None						,   **__a :		Optional[Any]						,   )	->     Optional[Any]:


												"""simple docstring"""

												super().__init__(
												    pad_token_id=__a						,   bos_token_id=__a						,   eos_token_id=__a						,   sep_token_id=__a						,   **__a						,   )

												__lowercase					:							Tuple			=   vocab_size
												__lowercase					:							List[str]			=   max_position_embeddings
												__lowercase					:							str			=   hidden_size
												__lowercase					:							List[str]			=   num_hidden_layers
												__lowercase					:							str			=   num_attention_heads
												__lowercase					:							Tuple			=   intermediate_size
												__lowercase					:							Dict			=   hidden_act
												__lowercase					:							int			=   hidden_dropout_prob
												__lowercase					:							Optional[Any]			=   attention_probs_dropout_prob
												__lowercase					:							Dict			=   initializer_range
												__lowercase					:							str			=   type_vocab_size
												__lowercase					:							Any			=   layer_norm_eps
												__lowercase					:							Any			=   use_cache

												__lowercase					:							Tuple			=   rescale_embeddings
												__lowercase					:							str			=   attention_type
												__lowercase					:							List[Any]			=   use_bias
												__lowercase					:							int			=   block_size
												__lowercase					:							Tuple			=   num_random_blocks
												__lowercase					:							Union[str, Any]			=   classifier_dropout







class 						lowerCAmelCase   (       __a	):

					'''simple docstring'''

					@property
					def 					lowerCAmelCase (     self :		List[Any]							)	->     Mapping[str, Mapping[int, str]]:


												"""simple docstring"""

												if self.task == "multiple-choice":
																			__lowercase					:							int			=   {0: """batch""", 1: """choice""", 2: """sequence"""}
												else:
																			__lowercase					:							List[Any]			=   {0: """batch""", 1: """sequence"""}
												return OrderedDict(
												    [
												        ("""input_ids""", dynamic_axis),
												        ("""attention_mask""", dynamic_axis),
												    ]							)







def 					snake_case_						(   lowerCAmelCase_				:  list					):

							if len(lowerCAmelCase_					) <= 1:
														return [tuple(lowerCAmelCase_					)]

							__lowercase					:							Any			=   []

							def generate(lowerCAmelCase_				:  int				,				lowerCAmelCase_				:  list					):
														if k == 1:
																					res.append(tuple(arr[:]					)					)
																					return

														generate(k - 1				,				lowerCAmelCase_					)

														for i in range(k - 1					):
																					if k % 2 == 0:  # k is even
																												__lowercase	,	__lowercase					:							List[str]			=   arr[k - 1], arr[i]
																					else:  # k is odd
																												__lowercase	,	__lowercase					:							Any			=   arr[k - 1], arr[0]
																					generate(k - 1				,				lowerCAmelCase_					)

							generate(len(lowerCAmelCase_					)				,				lowerCAmelCase_					)
							return res


if __name__ == "__main__":
	lowerCamelCase       :       Union[str, Any]        =				input('''Enter numbers separated by a comma:\n''').strip()
	lowerCamelCase       :       Optional[Any]        =				[int(item) for item in user_input.split(''',''')]
	print(heaps(arr))