'''simple docstring'''

from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


__snake_case       :   int  		=    {
    '''configuration_utils''': ['''GenerationConfig'''],
    '''streamers''': ['''TextIteratorStreamer''', '''TextStreamer'''],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __snake_case       :   str  		=    [
          '''Constraint''',
          '''ConstraintListState''',
          '''DisjunctiveConstraint''',
          '''PhrasalConstraint''',
      ]
      __snake_case       :   Any  		=    [
          '''BeamHypotheses''',
          '''BeamScorer''',
          '''BeamSearchScorer''',
          '''ConstrainedBeamSearchScorer''',
      ]
      __snake_case       :   Optional[Any]  		=    [
          '''EpsilonLogitsWarper''',
          '''EtaLogitsWarper''',
          '''ForcedBOSTokenLogitsProcessor''',
          '''ForcedEOSTokenLogitsProcessor''',
          '''HammingDiversityLogitsProcessor''',
          '''InfNanRemoveLogitsProcessor''',
          '''LogitsProcessor''',
          '''LogitsProcessorList''',
          '''LogitsWarper''',
          '''MinLengthLogitsProcessor''',
          '''MinNewTokensLengthLogitsProcessor''',
          '''NoBadWordsLogitsProcessor''',
          '''NoRepeatNGramLogitsProcessor''',
          '''PrefixConstrainedLogitsProcessor''',
          '''RepetitionPenaltyLogitsProcessor''',
          '''SequenceBiasLogitsProcessor''',
          '''EncoderRepetitionPenaltyLogitsProcessor''',
          '''TemperatureLogitsWarper''',
          '''TopKLogitsWarper''',
          '''TopPLogitsWarper''',
          '''TypicalLogitsWarper''',
          '''EncoderNoRepeatNGramLogitsProcessor''',
          '''ExponentialDecayLengthPenalty''',
          '''LogitNormalization''',
      ]
      __snake_case       :   Dict  		=    [
          '''MaxNewTokensCriteria''',
          '''MaxLengthCriteria''',
          '''MaxTimeCriteria''',
          '''StoppingCriteria''',
          '''StoppingCriteriaList''',
          '''validate_stopping_criteria''',
      ]
      __snake_case       :   Optional[int]  		=    [
          '''GenerationMixin''',
          '''top_k_top_p_filtering''',
          '''GreedySearchEncoderDecoderOutput''',
          '''GreedySearchDecoderOnlyOutput''',
          '''SampleEncoderDecoderOutput''',
          '''SampleDecoderOnlyOutput''',
          '''BeamSearchEncoderDecoderOutput''',
          '''BeamSearchDecoderOnlyOutput''',
          '''BeamSampleEncoderDecoderOutput''',
          '''BeamSampleDecoderOnlyOutput''',
          '''ContrastiveSearchEncoderDecoderOutput''',
          '''ContrastiveSearchDecoderOnlyOutput''',
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __snake_case       :   int  		=    [
          '''TFForcedBOSTokenLogitsProcessor''',
          '''TFForcedEOSTokenLogitsProcessor''',
          '''TFLogitsProcessor''',
          '''TFLogitsProcessorList''',
          '''TFLogitsWarper''',
          '''TFMinLengthLogitsProcessor''',
          '''TFNoBadWordsLogitsProcessor''',
          '''TFNoRepeatNGramLogitsProcessor''',
          '''TFRepetitionPenaltyLogitsProcessor''',
          '''TFTemperatureLogitsWarper''',
          '''TFTopKLogitsWarper''',
          '''TFTopPLogitsWarper''',
          '''TFForceTokensLogitsProcessor''',
          '''TFSuppressTokensAtBeginLogitsProcessor''',
          '''TFSuppressTokensLogitsProcessor''',
      ]
      __snake_case       :   List[Any]  		=    [
          '''TFGenerationMixin''',
          '''tf_top_k_top_p_filtering''',
          '''TFGreedySearchDecoderOnlyOutput''',
          '''TFGreedySearchEncoderDecoderOutput''',
          '''TFSampleEncoderDecoderOutput''',
          '''TFSampleDecoderOnlyOutput''',
          '''TFBeamSearchEncoderDecoderOutput''',
          '''TFBeamSearchDecoderOnlyOutput''',
          '''TFBeamSampleEncoderDecoderOutput''',
          '''TFBeamSampleDecoderOnlyOutput''',
          '''TFContrastiveSearchEncoderDecoderOutput''',
          '''TFContrastiveSearchDecoderOnlyOutput''',
      ]

try:
      if not is_flax_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __snake_case       :   str  		=    [
          '''FlaxForcedBOSTokenLogitsProcessor''',
          '''FlaxForcedEOSTokenLogitsProcessor''',
          '''FlaxLogitsProcessor''',
          '''FlaxLogitsProcessorList''',
          '''FlaxLogitsWarper''',
          '''FlaxMinLengthLogitsProcessor''',
          '''FlaxTemperatureLogitsWarper''',
          '''FlaxTopKLogitsWarper''',
          '''FlaxTopPLogitsWarper''',
      ]
      __snake_case       :   Dict  		=    [
          '''FlaxGenerationMixin''',
          '''FlaxGreedySearchOutput''',
          '''FlaxSampleOutput''',
          '''FlaxBeamSearchOutput''',
      ]

if TYPE_CHECKING:
      from .configuration_utils import GenerationConfig
      from .streamers import TextIteratorStreamer, TextStreamer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
            from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
            from .logits_process import (
                EncoderNoRepeatNGramLogitsProcessor,
                EncoderRepetitionPenaltyLogitsProcessor,
                EpsilonLogitsWarper,
                EtaLogitsWarper,
                ExponentialDecayLengthPenalty,
                ForcedBOSTokenLogitsProcessor,
                ForcedEOSTokenLogitsProcessor,
                HammingDiversityLogitsProcessor,
                InfNanRemoveLogitsProcessor,
                LogitNormalization,
                LogitsProcessor,
                LogitsProcessorList,
                LogitsWarper,
                MinLengthLogitsProcessor,
                MinNewTokensLengthLogitsProcessor,
                NoBadWordsLogitsProcessor,
                NoRepeatNGramLogitsProcessor,
                PrefixConstrainedLogitsProcessor,
                RepetitionPenaltyLogitsProcessor,
                SequenceBiasLogitsProcessor,
                TemperatureLogitsWarper,
                TopKLogitsWarper,
                TopPLogitsWarper,
                TypicalLogitsWarper,
            )
            from .stopping_criteria import (
                MaxLengthCriteria,
                MaxNewTokensCriteria,
                MaxTimeCriteria,
                StoppingCriteria,
                StoppingCriteriaList,
                validate_stopping_criteria,
            )
            from .utils import (
                BeamSampleDecoderOnlyOutput,
                BeamSampleEncoderDecoderOutput,
                BeamSearchDecoderOnlyOutput,
                BeamSearchEncoderDecoderOutput,
                ContrastiveSearchDecoderOnlyOutput,
                ContrastiveSearchEncoderDecoderOutput,
                GenerationMixin,
                GreedySearchDecoderOnlyOutput,
                GreedySearchEncoderDecoderOutput,
                SampleDecoderOnlyOutput,
                SampleEncoderDecoderOutput,
                top_k_top_p_filtering,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tf_logits_process import (
                TFForcedBOSTokenLogitsProcessor,
                TFForcedEOSTokenLogitsProcessor,
                TFForceTokensLogitsProcessor,
                TFLogitsProcessor,
                TFLogitsProcessorList,
                TFLogitsWarper,
                TFMinLengthLogitsProcessor,
                TFNoBadWordsLogitsProcessor,
                TFNoRepeatNGramLogitsProcessor,
                TFRepetitionPenaltyLogitsProcessor,
                TFSuppressTokensAtBeginLogitsProcessor,
                TFSuppressTokensLogitsProcessor,
                TFTemperatureLogitsWarper,
                TFTopKLogitsWarper,
                TFTopPLogitsWarper,
            )
            from .tf_utils import (
                TFBeamSampleDecoderOnlyOutput,
                TFBeamSampleEncoderDecoderOutput,
                TFBeamSearchDecoderOnlyOutput,
                TFBeamSearchEncoderDecoderOutput,
                TFContrastiveSearchDecoderOnlyOutput,
                TFContrastiveSearchEncoderDecoderOutput,
                TFGenerationMixin,
                TFGreedySearchDecoderOnlyOutput,
                TFGreedySearchEncoderDecoderOutput,
                TFSampleDecoderOnlyOutput,
                TFSampleEncoderDecoderOutput,
                tf_top_k_top_p_filtering,
            )

      try:
            if not is_flax_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .flax_logits_process import (
                FlaxForcedBOSTokenLogitsProcessor,
                FlaxForcedEOSTokenLogitsProcessor,
                FlaxLogitsProcessor,
                FlaxLogitsProcessorList,
                FlaxLogitsWarper,
                FlaxMinLengthLogitsProcessor,
                FlaxTemperatureLogitsWarper,
                FlaxTopKLogitsWarper,
                FlaxTopPLogitsWarper,
            )
            from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
      import sys

      __snake_case       :   List[Any]  		=    _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)

'''simple docstring'''

def lowerCamelCase__						(       A_       ):
 UpperCAmelCase_				       =					len(A_       )
 for _ in range(
     0       ,			int(((no_of_elements - 1) / 2) + 1       )       ):  # we don't need to traverse to end of list as
  for j in range(0       ,			no_of_elements - 1       ):
   if (
       lst[j + 1] < lst[j]
   ):  # applying bubble sort algorithm from left to right (or forwards)
    UpperCAmelCase_				       =					lst[j + 1]
    UpperCAmelCase_				       =					lst[j]
    UpperCAmelCase_				       =					temp
   if (
       lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
   ):  # applying bubble sort algorithm from right to left (or backwards)
    UpperCAmelCase_				       =					lst[no_of_elements - 1 - j]
    UpperCAmelCase_				       =					lst[no_of_elements - 2 - j]
    UpperCAmelCase_				       =					temp
 return lst


if __name__ == "__main__":
      print('''enter the list to be sorted''')
      __snake_case       :   List[str]  		=    [int(x) for x in input().split()]  # inputing elements of the list in one line
      __snake_case       :   Optional[int]  		=    double_sort(lst)
      print('''the sorted list is''')
      print(sorted_lst)
