


from typing import Any






class    UpperCAmelCase__	:



    """simple docstring"""






    def __init__(      self ,       A_   )  ->	Tuple:
         __UpperCamelCase   							=data
         __UpperCamelCase   							=None






    def __repr__(      self   )  ->	str:
         return f'Node({self.data})'






class    UpperCAmelCase__	:



    """simple docstring"""






    def __init__(      self   )  ->	Dict:
         __UpperCamelCase   							=None






    def __iter__(      self   )  ->	Any:
         __UpperCamelCase   							=self.head
         while node:
              yield node.data
              __UpperCamelCase   							=node.next






    def __len__(      self   )  ->	int:
         return sum(1 for _ in self   )






    def __repr__(      self   )  ->	str:
         return "->".join([str(A_   ) for item in self]   )






    def __getitem__(      self ,       A_   )  ->	Any:
         if not 0 <= index < len(self   ):
              raise ValueError('list index out of range.'   )
         for i, node in enumerate(self   ):
              if i == index:
                   return node
         return None






    def __setitem__(      self ,       A_ ,       A_   )  ->	None:
         if not 0 <= index < len(self   ):
              raise ValueError('list index out of range.'   )
         __UpperCamelCase   							=self.head
         for _ in range(A_   ):
              __UpperCamelCase   							=current.next
         __UpperCamelCase   							=data






    def _a (      self ,       A_   )  ->	None:
         self.insert_nth(len(self   ) ,       A_   )






    def _a (      self ,       A_   )  ->	None:
         self.insert_nth(0 ,       A_   )






    def _a (      self ,       A_ ,       A_   )  ->	None:
         if not 0 <= index <= len(self   ):
              raise IndexError('list index out of range'   )
         __UpperCamelCase   							=Node(A_   )
         if self.head is None:
              __UpperCamelCase   							=new_node
         elif index == 0:
              __UpperCamelCase   							=self.head  # link new_node to head
              __UpperCamelCase   							=new_node
         else:
              __UpperCamelCase   							=self.head
              for _ in range(index - 1   ):
                   __UpperCamelCase   							=temp.next
              __UpperCamelCase   							=temp.next
              __UpperCamelCase   							=new_node






    def _a (      self   )  ->	None:  # print every node data
         print(self   )






    def _a (      self   )  ->	Any:
         return self.delete_nth(0   )






    def _a (      self   )  ->	Any:  # delete from tail
         return self.delete_nth(len(self   ) - 1   )






    def _a (      self ,       A_ = 0   )  ->	Any:
         if not 0 <= index <= len(self   ) - 1:  # test if index is valid
              raise IndexError('List index out of range.'   )
         __UpperCamelCase   							=self.head  # default first node
         if index == 0:
              __UpperCamelCase   							=self.head.next
         else:
              __UpperCamelCase   							=self.head
              for _ in range(index - 1   ):
                   __UpperCamelCase   							=temp.next
              __UpperCamelCase   							=temp.next
              __UpperCamelCase   							=temp.next.next
         return delete_node.data






    def _a (      self   )  ->	bool:
         return self.head is None






    def _a (      self   )  ->	None:
         __UpperCamelCase   							=None
         __UpperCamelCase   							=self.head

         while current:
              # Store the current node's next node.
              __UpperCamelCase   							=current.next
              # Make the current node's next point backwards
              __UpperCamelCase   							=prev
              # Make the previous node be the current node
              __UpperCamelCase   							=current
              # Make the current node the next node (to progress iteration)
              __UpperCamelCase   							=next_node
         # Return prev in order to put the head at the end
         __UpperCamelCase   							=prev

def 						_UpperCAmelCase    (      ):
     __UpperCamelCase   							=LinkedList()
     assert linked_list.is_empty() is True
     assert str(SCREAMING_SNAKE_CASE__    ) == ""

     try:
          linked_list.delete_head()
          raise AssertionError  # This should not happen.
     except IndexError:
          assert True  # This should happen.

     try:
          linked_list.delete_tail()
          raise AssertionError  # This should not happen.
     except IndexError:
          assert True  # This should happen.

     for i in range(10    ):
          assert len(SCREAMING_SNAKE_CASE__    ) == i
          linked_list.insert_nth(SCREAMING_SNAKE_CASE__      ,					i + 1    )
     assert str(SCREAMING_SNAKE_CASE__    ) == "->".join(str(SCREAMING_SNAKE_CASE__    ) for i in range(1      ,					11    )    )

     linked_list.insert_head(0    )
     linked_list.insert_tail(11    )
     assert str(SCREAMING_SNAKE_CASE__    ) == "->".join(str(SCREAMING_SNAKE_CASE__    ) for i in range(0      ,					12    )    )

     assert linked_list.delete_head() == 0
     assert linked_list.delete_nth(9    ) == 10
     assert linked_list.delete_tail() == 11
     assert len(SCREAMING_SNAKE_CASE__    ) == 9
     assert str(SCREAMING_SNAKE_CASE__    ) == "->".join(str(SCREAMING_SNAKE_CASE__    ) for i in range(1      ,					10    )    )

     assert all(linked_list[i] == i + 1 for i in range(0      ,					9    )    ) is True

     for i in range(0      ,					9    ):
          __UpperCamelCase   							=-i
     assert all(linked_list[i] == -i for i in range(0      ,					9    )    ) is True

     linked_list.reverse()
     assert str(SCREAMING_SNAKE_CASE__    ) == "->".join(str(SCREAMING_SNAKE_CASE__    ) for i in range(-8      ,					1    )    )

def 						_UpperCAmelCase    (      ):
     __UpperCamelCase   							=[
         -9,
         1_00,
         Node(77_34_51_12    ),
         'dlrow olleH',
         7,
         55_55,
         0,
         -192.55555,
         'Hello, world!',
         77.9,
         Node(10    ),
         None,
         None,
         12.20,
     ]
     __UpperCamelCase   							=LinkedList()

     for i in test_input:
          linked_list.insert_tail(SCREAMING_SNAKE_CASE__    )

     # Check if it's empty or not
     assert linked_list.is_empty() is False
     assert (
         str(SCREAMING_SNAKE_CASE__    ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
         "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
     )

     # Delete the head
     __UpperCamelCase   							=linked_list.delete_head()
     assert result == -9
     assert (
         str(SCREAMING_SNAKE_CASE__    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
         "Hello, world!->77.9->Node(10)->None->None->12.2"
     )

     # Delete the tail
     __UpperCamelCase   							=linked_list.delete_tail()
     assert result == 12.2
     assert (
         str(SCREAMING_SNAKE_CASE__    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
         "Hello, world!->77.9->Node(10)->None->None"
     )

     # Delete a node in specific location in linked list
     __UpperCamelCase   							=linked_list.delete_nth(10    )
     assert result is None
     assert (
         str(SCREAMING_SNAKE_CASE__    ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
         "Hello, world!->77.9->Node(10)->None"
     )

     # Add a Node instance to its head
     linked_list.insert_head(Node('Hello again, world!'    )    )
     assert (
         str(SCREAMING_SNAKE_CASE__    )
         == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
         "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
     )

     # Add None to its tail
     linked_list.insert_tail(SCREAMING_SNAKE_CASE__    )
     assert (
         str(SCREAMING_SNAKE_CASE__    )
         == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
         "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
     )

     # Reverse the linked list
     linked_list.reverse()
     assert (
         str(SCREAMING_SNAKE_CASE__    )
         == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
         "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
     )

def 						_UpperCAmelCase    (      ):
     from doctest import testmod

     testmod()

     __UpperCamelCase   							=LinkedList()
     linked_list.insert_head(input('Inserting 1st at head '    ).strip()    )
     linked_list.insert_head(input('Inserting 2nd at head '    ).strip()    )
     print('\nPrint list:'    )
     linked_list.print_list()
     linked_list.insert_tail(input('\nInserting 1st at tail '    ).strip()    )
     linked_list.insert_tail(input('Inserting 2nd at tail '    ).strip()    )
     print('\nPrint list:'    )
     linked_list.print_list()
     print('\nDelete head'    )
     linked_list.delete_head()
     print('Delete tail'    )
     linked_list.delete_tail()
     print('\nPrint list:'    )
     linked_list.print_list()
     print('\nReverse linked list'    )
     linked_list.reverse()
     print('\nPrint list:'    )
     linked_list.print_list()
     print('\nString representation of linked list:'    )
     print(SCREAMING_SNAKE_CASE__    )
     print('\nReading/changing Node data using indexing:'    )
     print(F'Element at Position 1: {linked_list[1]}'    )
     __UpperCamelCase   							=input('Enter New Value: '    ).strip()
     print('New list:'    )
     print(SCREAMING_SNAKE_CASE__    )
     print(F'length of linked_list is : {len(SCREAMING_SNAKE_CASE__    )}'    )


if __name__ == "__main__":
   main()









# Copyright 2021 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import argparse

from ...utils.dataclasses import (
    ComputeEnvironment,
    DistributedType,
    DynamoBackend,
    PrecisionType,
    SageMakerDistributedType,
)
from ..menu import BulletMenu


_A			=						[
    'EAGER',
    'AOT_EAGER',
    'INDUCTOR',
    'NVFUSER',
    'AOT_NVFUSER',
    'AOT_CUDAGRAPHS',
    'OFI',
    'FX2TRT',
    'ONNXRT',
    'IPEX',
]

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[int]      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]=None      ,					SCREAMING_SNAKE_CASE__      : Optional[Any]=None      ,					SCREAMING_SNAKE_CASE__      : str=None    ):
     __UpperCamelCase   							=True
     while ask_again:
          __UpperCamelCase   							=input(SCREAMING_SNAKE_CASE__    )
          try:
               if default is not None and len(SCREAMING_SNAKE_CASE__    ) == 0:
                    return default
               return convert_value(SCREAMING_SNAKE_CASE__    ) if convert_value is not None else result
          except Exception:
               if error_message is not None:
                    print(SCREAMING_SNAKE_CASE__    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[Any]      ,					SCREAMING_SNAKE_CASE__      : List[str]=[]      ,					SCREAMING_SNAKE_CASE__      : Union[str, Any]=None      ,					SCREAMING_SNAKE_CASE__      : str=0    ):
     __UpperCamelCase   							=BulletMenu(SCREAMING_SNAKE_CASE__      ,					SCREAMING_SNAKE_CASE__    )
     __UpperCamelCase   							=menu.run(default_choice=SCREAMING_SNAKE_CASE__    )
     return convert_value(SCREAMING_SNAKE_CASE__    ) if convert_value is not None else result

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Union[str, Any]    ):
     __UpperCamelCase   							=int(SCREAMING_SNAKE_CASE__    )
     return ComputeEnvironment(['LOCAL_MACHINE', 'AMAZON_SAGEMAKER'][value]    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : List[str]    ):
     __UpperCamelCase   							=int(SCREAMING_SNAKE_CASE__    )
     return DistributedType(['NO', 'MULTI_CPU', 'MULTI_XPU', 'MULTI_GPU', 'MULTI_NPU', 'TPU'][value]    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[int]    ):
     __UpperCamelCase   							=int(SCREAMING_SNAKE_CASE__    )
     return DynamoBackend(DYNAMO_BACKENDS[value]    ).value

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Dict    ):
     __UpperCamelCase   							=int(SCREAMING_SNAKE_CASE__    )
     return PrecisionType(['no', 'fp16', 'bf16', 'fp8'][value]    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Optional[Any]    ):
     __UpperCamelCase   							=int(SCREAMING_SNAKE_CASE__    )
     return SageMakerDistributedType(['NO', 'DATA_PARALLEL', 'MODEL_PARALLEL'][value]    )

def 						_UpperCAmelCase    (      SCREAMING_SNAKE_CASE__      : Any    ):
     return {"yes": True, "no": False}[value.lower()]






class    UpperCAmelCase__	( argparse.RawDescriptionHelpFormatter		):



    """simple docstring"""






    def _a (      self ,       A_ ,       A_ ,       A_ ,       A_   )  ->	Optional[int]:
         __UpperCamelCase   							=super()._format_usage(A_ ,       A_ ,       A_ ,       A_   )
         __UpperCamelCase   							=usage.replace('<command> [<args>] ' ,       ''   )
         return usage





