


from __future__ import annotations





def 	_lowerCAmelCase					( UpperCamelCase__:  list[int]    )			-> list[int]:





	"""simple docstring"""







	if len(UpperCamelCase__    ) == 0:
		return array

	A       ,      A             =					min(UpperCamelCase__    ), max(UpperCamelCase__    )

	# Compute the variables
	A             =					_max - _min + 1
	A       ,      A             =					[0] * holes_range, [0] * holes_range

	# Make the sorting.
	for i in array:
		A             =					i - _min
		A             =					i
		holes_repeat[index] += 1

	# Makes the array back by replacing the numbers.
	A             =					0
	for i in range(UpperCamelCase__    ):
		while holes_repeat[i] > 0:
			A             =					holes[i]
			index += 1
			holes_repeat[i] -= 1

    # Returns the sorted array.
	return array


if __name__ == "__main__":
				import doctest

				doctest.testmod()
				_lowercase							:   Tuple						=						input("Enter numbers separated by comma:\n")
				_lowercase							:   Optional[Any]						=						[int(x) for x in user_input.split(",")]
				print(pigeon_sort(unsorted))







import numpy as np

from transformers import Pipeline





def 	_lowerCAmelCase					( UpperCamelCase__:  Optional[Any]    )			-> Optional[int]:





	"""simple docstring"""







	A             =					np.max(UpperCamelCase__				,       axis=-1				,       keepdims=UpperCamelCase__    )
	A             =					np.exp(outputs - maxes    )
	return shifted_exp / shifted_exp.sum(axis=-1				,       keepdims=UpperCamelCase__    )






class    _UpperCamelCase     (       __snake_case					):

				"""simple docstring"""







				def   _UpperCAmelCase       (    self					, **a__ )						->					Union[str, Any]:
					A             =					{}
					if "second_text" in kwargs:
						A             =					kwargs["""second_text"""]
					return preprocess_kwargs, {}, {}

				def   _UpperCAmelCase       (    self					, a__					, a__=None )						->					str:
					return self.tokenizer(a__					, text_pair=a__					, return_tensors=self.framework )

				def   _UpperCAmelCase       (    self					, a__ )						->					Tuple:
					return self.model(**a__ )

				def   _UpperCAmelCase       (    self					, a__ )						->					Optional[int]:
					A             =					model_outputs.logits[0].numpy()
					A             =					softmax(a__ )

					A             =					np.argmax(a__ )
					A             =					self.model.config.idalabel[best_class]
					A             =					probabilities[best_class].item()
					A             =					logits.tolist()
					return {"label": label, "score": score, "logits": logits}



