from __future__ import annotations




def    lowerCAmelCase_ (     __A							)     ->				None:







      '''simple docstring'''


      create_state_space_tree(__A,  [],  0,  [0 for i in range(len(__A							)							)]							)




def    lowerCAmelCase_ (     __A,  __A,  __A,  __A,  )     ->				None:







      '''simple docstring'''


      if index == len(__A							):
            print(__A							)
            return

      for i in range(len(__A							)							):
            if not index_used[i]:
                  current_sequence.append(sequence[i]							)
                  UpperCAmelCase__								=  True
                  create_state_space_tree(__A,  __A,  index + 1,  __A							)
                  current_sequence.pop()
                  UpperCAmelCase__								=  False
UpperCamelCase__											=					[3, 1, 2, 4]
generate_all_permutations(sequence)

UpperCamelCase__											=					["A", "B", "C"]







generate_all_permutations(sequence_a)










from __future__ import annotations

from collections.abc import Iterable, Iterator
from dataclasses import dataclass

snake_case__					:							Union[str, Any]													=     (3, 9, -11, 0, 7, 5, 1, -1)
snake_case__					:							int													=     (4, 6, 2, 0, 8, 10, 3, -2)





@dataclass
class A_					:
   lowerCAmelCase__        = 42
   lowerCAmelCase__        = 42





class A_					:




   def __init__(self	:Dict    ,   _UpperCamelCase	:Iterable[int] )->					None:
         __A          =				None
         for i in sorted(_UpperCamelCase    ,   reverse=_UpperCamelCase ):
               __A          =				Node(_UpperCamelCase    ,   self.head )




   def __iter__(self	:List[str] )->					Iterator[int]:
         __A          =				self.head
         while node:
               yield node.data
               __A          =				node.next_node




   def __len__(self	:Union[str, Any] )->					int:
         return sum(1 for _ in self )






   def __str__(self	:List[Any] )->					str:
         return " -> ".join([str(_UpperCamelCase ) for node in self] )





def _a				(	lowerCamelCase:   SortedLinkedList					,				lowerCamelCase:   SortedLinkedList )	->						SortedLinkedList:







      '''simple docstring'''






      return SortedLinkedList(list(lowerCamelCase ) + list(lowerCamelCase ) )


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       snake_case__					:							Any													=     SortedLinkedList
       print(merge_lists(SSL(test_data_odd), SSL(test_data_even)))





