| f | class NegExt: | f | class NegExt: | 
             |  |  |  | 
             |     def __neg__(self): |  |     def __neg__(self): | 
            | n |         class_reference = self.__class__ | n |         cls = self.__class__ | 
             |         for ancestor in class_reference.__mro__[1:]: |  |         for base in cls.__mro__[1:]: | 
             |             if hasattr(ancestor, '__neg__') and callable(ancestor.__neg_ |  |             if hasattr(base, '__neg__') and callable(base.__neg__) and ( | 
             | _) and (ancestor is not NegExt): |  | base is not NegExt): | 
             |                 try: |  |                 try: | 
            | n |                     neg_result = ancestor.__neg__(self) | n |                     result = base.__neg__(self) | 
             |                     return class_reference(neg_result) |  |                     return cls(result) | 
             |                 except TypeError: |  |                 except TypeError: | 
             |                     continue |  |                     continue | 
             |         if hasattr(self, '__getitem__'): |  |         if hasattr(self, '__getitem__'): | 
             |             try: |  |             try: | 
            | n |                 sliced_part = self[1:-1] | n |                 sliced = self[1:-1] | 
             |                 return class_reference(sliced_part) if not isinstance(se |  |                 return cls(sliced) if not isinstance(self, dict) else cl | 
             | lf, dict) else class_reference(sliced_part.items()) |  | s(sliced.items()) | 
             |             except (TypeError, IndexError, KeyError): |  |             except (TypeError, IndexError, KeyError): | 
             |                 pass |  |                 pass | 
            | t |         return class_reference(self) if not isinstance(self, dict) else  | t |         return cls(self) if not isinstance(self, dict) else cls(self.ite | 
             | class_reference(self.items()) |  | ms()) |