




'''simple docstring'''





from __future__ import annotations

from bisect import bisect_left
from functools import total_ordering
from heapq import merge




@total_ordering
class 			_snake_case		(     a__							):




			def __lt__( self    ,							a__							)    ->    int:

										'''simple docstring'''




										return self[-1] < other[-1]




			def __eq__( self    ,							a__							)    ->    List[Any]:

										'''simple docstring'''




										return self[-1] == other[-1]


def 					UpperCamelCase_(     snake_case							:	list					):

							'''simple docstring'''






							snake_case_      =				[]
							# sort into stacks
							for element in collection:
														snake_case_      =				Stack([element]					)
														snake_case_      =				bisect_left(lowerCamelCase__							,    lowerCamelCase__					)
														if i != len(lowerCamelCase__					):
																					stacks[i].append(lowerCamelCase__					)
														else:
																					stacks.append(lowerCamelCase__					)

    # use a heap-based merge to merge stack efficiently
							snake_case_      =				merge(*(reversed(lowerCamelCase__					) for stack in stacks)					)
							return collection


if __name__ == "__main__":
	_SCREAMING_SNAKE_CASE							:       str						=			input("Enter numbers separated by a comma:\n").strip()
	_SCREAMING_SNAKE_CASE							:       Tuple						=			[int(item) for item in user_input.split(",")]
	print(patience_sort(unsorted))










'''simple docstring'''





from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
		import tensorflow as tf

		from transformers.models.layoutlm.modeling_tf_layoutlm import (
		    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
		    TFLayoutLMForMaskedLM,
		    TFLayoutLMForQuestionAnswering,
		    TFLayoutLMForSequenceClassification,
		    TFLayoutLMForTokenClassification,
		    TFLayoutLMModel,
		)




class 			_snake_case		:




			def __init__( self    ,							a__    ,							a__=13    ,							a__=7    ,							a__=True    ,							a__=True    ,							a__=True    ,							a__=True    ,							a__=99    ,							a__=32    ,							a__=2    ,							a__=4    ,							a__=37    ,							a__="gelu"    ,							a__=0.1    ,							a__=0.1    ,							a__=512    ,							a__=16    ,							a__=2    ,							a__=0.0_2    ,							a__=3    ,							a__=4    ,							a__=None    ,							a__=1_000    ,							)    ->    Optional[int]:

										'''simple docstring'''




										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_      =				hidden_size
										snake_case_      =				num_hidden_layers
										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
										snake_case_      =				range_bbox




			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				ids_tensor([self.batch_size, self.seq_length]    ,							self.vocab_size							)

										# convert bbox to numpy since TF does not support item assignment
										snake_case_      =				ids_tensor([self.batch_size, self.seq_length, 4]    ,							self.range_bbox							).numpy()
										# Ensure that bbox is legal
										for i in range(bbox.shape[0]							):
																	for j in range(bbox.shape[1]							):
																								if bbox[i, j, 3] < bbox[i, j, 1]:
																															snake_case_      =				bbox[i, j, 3]
																															snake_case_      =				bbox[i, j, 1]
																															snake_case_      =				t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																															snake_case_      =				bbox[i, j, 2]
																															snake_case_      =				bbox[i, j, 0]
																															snake_case_      =				t
										snake_case_      =				tf.convert_to_tensor(a__							)

										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_      =				LayoutLMConfig(
										    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    ,							)

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




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Optional[Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModel(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=a__							)
										snake_case_      =				model(a__    ,							a__    ,							token_type_ids=a__							)
										snake_case_      =				model(a__    ,							a__							)
										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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForMaskedLM(config=a__							)

										snake_case_      =				model(a__    ,							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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.num_labels
										snake_case_      =				TFLayoutLMForSequenceClassification(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=a__							)
										self.parent.assertEqual(result.logits.shape    ,							(self.batch_size, self.num_labels)							)




			def        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				self.num_labels
										snake_case_      =				TFLayoutLMForTokenClassification(config=a__							)

										snake_case_      =				model(a__    ,							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        lowerCAmelCase__    ( self    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__    ,							a__							)    ->    Union[str, Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForQuestionAnswering(config=a__							)

										snake_case_      =				model(a__    ,							a__    ,							attention_mask=a__    ,							token_type_ids=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        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.prepare_config_and_inputs()
										(
										    (
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				(
										    snake_case_
										) ,				
										)      =				config_and_inputs
										snake_case_      =				{
										    "input_ids": input_ids,
										    "bbox": bbox,
										    "token_type_ids": token_type_ids,
										    "attention_mask": input_mask,
										}
										return config, inputs_dict




@require_tf
class 			_snake_case		(     lowercase_						,						lowercase_						,						unittest.TestCase							):
			lowerCAmelCase_					:				Optional[int]							=   (
			    (
			        TFLayoutLMModel,
			        TFLayoutLMForMaskedLM,
			        TFLayoutLMForTokenClassification,
			        TFLayoutLMForSequenceClassification,
			        TFLayoutLMForQuestionAnswering,
			    )
			    if is_tf_available()
			    else ()
			)
			lowerCAmelCase_					:				List[Any]							=   (
			    {
			        "feature-extraction": TFLayoutLMModel,
			        "fill-mask": TFLayoutLMForMaskedLM,
			        "text-classification": TFLayoutLMForSequenceClassification,
			        "token-classification": TFLayoutLMForTokenClassification,
			        "zero-shot": TFLayoutLMForSequenceClassification,
			    }
			    if is_tf_available()
			    else {}
			)
			lowerCAmelCase_					:				Union[str, Any]							=   False
			lowerCAmelCase_					:				int							=   True
			lowerCAmelCase_					:				List[str]							=   10




			def        lowerCAmelCase__    ( self							)    ->    List[str]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModelTester(self							)
										snake_case_      =				ConfigTester(self    ,							config_class=a__    ,							hidden_size=37							)




			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										self.config_tester.run_common_tests()




			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_masked_lm(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_sequence_classification(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Optional[int]:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_token_classification(*a__							)




			def        lowerCAmelCase__    ( self							)    ->    Tuple:

										'''simple docstring'''




										snake_case_      =				self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_question_answering(*a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Dict:

										'''simple docstring'''




										for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	snake_case_      =				TFLayoutLMModel.from_pretrained(a__							)
																	self.assertIsNotNone(a__							)




			@unittest.skip("Onnx compliancy broke with TF 2.10"							)
			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




										pass


def 					UpperCamelCase_(     ):

							'''simple docstring'''






							snake_case_      =				tf.convert_to_tensor([[1_0_1,1_0_1_9,1_0_1_4,1_0_1_6,1_0_3_7,1_2_8_4_9,4_7_4_7,1_0_0_4,1_4_2_4_6,2_2_7_8,5_4_3_9,4_5_2_4,5_0_0_2,2_9_3_0,2_1_9_3,2_9_3_0,4_3_4_1,3_2_0_8,1_0_0_5,1_0_5_5,2_1_7_1,2_8_4_8,1_1_3_0_0,3_5_3_1,1_0_2],[1_0_1,4_0_7_0,4_0_3_4,7_0_2_0,1_0_2_4,3_0_5_8,1_0_1_5,1_0_1_3,2_8_6_1,1_0_1_3,6_0_7_0,1_9_2_7_4,2_7_7_2,6_2_0_5,2_7_8_1_4,1_6_1_4_7,1_6_1_4_7,4_3_4_3,2_0_4_7,1_0_2_8_3,1_0_9_6_9,1_4_3_8_9,1_0_1_2,2_3_3_8,1_0_2]]					)  # noqa: E231
							snake_case_      =				tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]					)  # noqa: E231
							snake_case_      =				tf.convert_to_tensor([[[0,0,0,0],[4_2_3,2_3_7,4_4_0,2_5_1],[4_2_7,2_7_2,4_4_1,2_8_7],[4_1_9,1_1_5,4_3_7,1_2_9],[9_6_1,8_8_5,9_9_2,9_1_2],[2_5_6,3_8,3_3_0,5_8],[2_5_6,3_8,3_3_0,5_8],[3_3_6,4_2,3_5_3,5_7],[3_6_0,3_9,4_0_1,5_6],[3_6_0,3_9,4_0_1,5_6],[4_1_1,3_9,4_7_1,5_9],[4_7_9,4_1,5_2_8,5_9],[5_3_3,3_9,6_3_0,6_0],[6_7,1_1_3,1_3_4,1_3_1],[1_4_1,1_1_5,2_0_9,1_3_2],[6_8,1_4_9,1_3_3,1_6_6],[1_4_1,1_4_9,1_8_7,1_6_4],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[1_9_5,1_4_8,2_8_7,1_6_5],[2_9_5,1_4_8,3_4_9,1_6_5],[4_4_1,1_4_9,4_9_2,1_6_6],[4_9_7,1_4_9,5_4_6,1_6_4],[6_4,2_0_1,1_2_5,2_1_8],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]],[[0,0,0,0],[6_6_2,1_5_0,7_5_4,1_6_6],[6_6_5,1_9_9,7_4_2,2_1_1],[5_1_9,2_1_3,5_5_4,2_2_8],[5_1_9,2_1_3,5_5_4,2_2_8],[1_3_4,4_3_3,1_8_7,4_5_4],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[1_3_0,4_6_7,2_0_4,4_8_0],[3_1_4,4_6_9,3_7_6,4_8_2],[5_0_4,6_8_4,5_8_2,7_0_6],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[9_4_1,8_2_5,9_7_3,9_0_0],[6_1_0,7_4_9,6_5_2,7_6_5],[1_3_0,6_5_9,1_6_8,6_7_2],[1_7_6,6_5_7,2_3_7,6_7_2],[2_3_8,6_5_7,3_1_2,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[4_4_3,6_5_3,6_2_8,6_7_2],[7_1_6,3_0_1,8_2_5,3_1_7],[1_0_0_0,1_0_0_0,1_0_0_0,1_0_0_0]]]					)  # noqa: E231
							snake_case_      =				tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]					)  # noqa: E231
							# these are sequence labels (i.e. at the token level)
							snake_case_      =				tf.convert_to_tensor([[-1_0_0,1_0,1_0,1_0,9,1,-1_0_0,7,7,-1_0_0,7,7,4,2,5,2,8,8,-1_0_0,-1_0_0,5,0,3,2,-1_0_0],[-1_0_0,1_2,1_2,1_2,-1_0_0,1_2,1_0,-1_0_0,-1_0_0,-1_0_0,-1_0_0,1_0,1_2,9,-1_0_0,-1_0_0,-1_0_0,1_0,1_0,1_0,9,1_2,-1_0_0,1_0,-1_0_0]]					)  # noqa: E231
							# fmt: on

							return input_ids, attention_mask, bbox, token_type_ids, labels




@require_tf
class 			_snake_case		(     unittest.TestCase							):




			@slow
			def        lowerCAmelCase__    ( self							)    ->    int:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMModel.from_pretrained("microsoft/layoutlm-base-uncased"							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__							)

										# test the sequence output on [0, :3, :3]
										snake_case_      =				tf.convert_to_tensor(
										    [[0.1_7_8_5, -0.1_9_4_7, -0.0_4_2_5], [-0.3_2_5_4, -0.2_8_0_7, 0.2_5_5_3], [-0.5_3_9_1, -0.3_3_2_2, 0.3_3_6_4]]    ,							)

										self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]    ,							a__    ,							atol=1e-3							)							)

										# test the pooled output on [1, :3]
										snake_case_      =				tf.convert_to_tensor([-0.6_5_8_0, -0.0_2_1_4, 0.8_5_5_2]							)

										self.assertTrue(np.allclose(outputs.pooler_output[1, :3]    ,							a__    ,							atol=1e-3							)							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Any:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForSequenceClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,							num_labels=2							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(
										    input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__    ,							labels=tf.convert_to_tensor([1, 1]							)    ,							)

										# test whether we get a loss as a scalar
										snake_case_      =				outputs.loss
										snake_case_      =				(2,)
										self.assertEqual(loss.shape    ,							a__							)

										# test the shape of the logits
										snake_case_      =				outputs.logits
										snake_case_      =				(2, 2)
										self.assertEqual(logits.shape    ,							a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    Union[str, Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased"    ,							num_labels=13							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(
										    input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__    ,							labels=a__							)

										# test the shape of the logits
										snake_case_      =				outputs.logits
										snake_case_      =				tf.convert_to_tensor((2, 25, 13)							)
										self.assertEqual(logits.shape    ,							a__							)




			@slow
			def        lowerCAmelCase__    ( self							)    ->    List[Any]:

										'''simple docstring'''




										snake_case_      =				TFLayoutLMForQuestionAnswering.from_pretrained("microsoft/layoutlm-base-uncased"							)

										snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_ ,				snake_case_      =				prepare_layoutlm_batch_inputs()

										# forward pass
										snake_case_      =				model(input_ids=a__    ,							bbox=a__    ,							attention_mask=a__    ,							token_type_ids=a__							)

										# test the shape of the logits
										snake_case_      =				tf.convert_to_tensor((2, 25)							)
										self.assertEqual(outputs.start_logits.shape    ,							a__							)
										self.assertEqual(outputs.end_logits.shape    ,							a__							)




