diff -r 6d5d2bda6acb Lib/operator.py
--- a/Lib/operator.py	Wed Jun 03 11:11:22 2015 -0600
+++ b/Lib/operator.py	Sun Jul 12 00:03:00 2015 -0400
@@ -408,6 +408,20 @@
     return a
 
 
+@object.__new__
+class subscript:
+    __slots__ = ()
+
+    def __new__(cls):
+        raise TypeError("cannot create '{}' instances".format(cls.__name__))
+
+    def __getitem__(self, key):
+        return key
+
+    def __reduce__(self):
+        return 'subscript'
+
+
 try:
     from _operator import *
 except ImportError:
diff -r 6d5d2bda6acb Lib/test/test_operator.py
--- a/Lib/test/test_operator.py	Wed Jun 03 11:11:22 2015 -0600
+++ b/Lib/test/test_operator.py	Sun Jul 12 00:03:00 2015 -0400
@@ -596,5 +596,1038 @@
     module2 = c_operator
 
 
+class SubscriptTestCase:
+    def test_subscript(self):
+        subscript = self.module.subscript
+        self.assertIs(..., subscript[...])
+        self.assertIs(None, subscript[None])
+        self.assertIs('', subscript[''])
+        self.assertIs(5, subscript[5])
+        self.assertEqual(slice(None, None, None), subscript[:])
+        self.assertEqual(slice(None, None, None), subscript[::])
+        self.assertEqual(slice(1, 1, 1), subscript[1:1:1])
+        self.assertEqual(slice(1, 1, None), subscript[1:1])
+        self.assertEqual(slice(1, 1, None), subscript[1:1:])
+        self.assertEqual(slice(1, None, 1), subscript[1::1])
+        self.assertEqual(slice(1, None, None), subscript[1:])
+        self.assertEqual(slice(1, None, None), subscript[1::])
+        self.assertEqual(slice(None, 1, 1), subscript[:1:1])
+        self.assertEqual(slice(None, 1, None), subscript[:1])
+        self.assertEqual(slice(None, 1, None), subscript[:1:])
+        self.assertEqual(slice(-1, -1, -1), subscript[-1:-1:-1])
+        self.assertEqual(slice(-1, -1, None), subscript[-1:-1])
+        self.assertEqual(slice(-1, -1, None), subscript[-1:-1:])
+        self.assertEqual(slice(-1, None, -1), subscript[-1::-1])
+        self.assertEqual(slice(-1, None, None), subscript[-1:])
+        self.assertEqual(slice(-1, None, None), subscript[-1::])
+        self.assertEqual(slice(None, -1, -1), subscript[:-1:-1])
+        self.assertEqual(slice(None, -1, None), subscript[:-1])
+        self.assertEqual(slice(None, -1, None), subscript[:-1:])
+        self.assertEqual(slice(1, -1, -1), subscript[1:-1:-1])
+        self.assertEqual(slice(-1, 1, -1), subscript[-1:1:-1])
+        self.assertEqual(slice(-1, -1, 1), subscript[-1:-1:1])
+        self.assertEqual(slice(1, 1, -1), subscript[1:1:-1])
+        self.assertEqual(slice(1, -1, 1), subscript[1:-1:1])
+        self.assertEqual(slice(-1, 1, 1), subscript[-1:1:1])
+        self.assertEqual(slice(1, -1, None), subscript[1:-1])
+        self.assertEqual(slice(-1, 1, None), subscript[-1:1])
+        self.assertEqual(slice(1, None, -1), subscript[1::-1])
+        self.assertEqual(slice(-1, None, 1), subscript[-1::1])
+        self.assertEqual(slice(None, 1, -1), subscript[:1:-1])
+        self.assertEqual(slice(None, -1, 1), subscript[:-1:1])
+        self.assertEqual((Ellipsis, None), subscript[..., None])
+        self.assertEqual((Ellipsis, ''), subscript[..., ''])
+        self.assertEqual((Ellipsis, 5), subscript[..., 5])
+        self.assertEqual((Ellipsis, slice(None, None, None)), subscript[..., :])
+        self.assertEqual((Ellipsis, slice(None, None, None)), subscript[..., ::])
+        self.assertEqual((Ellipsis, slice(1, 1, 1)), subscript[..., 1:1:1])
+        self.assertEqual((Ellipsis, slice(1, 1, None)), subscript[..., 1:1])
+        self.assertEqual((Ellipsis, slice(1, None, 1)), subscript[..., 1::1])
+        self.assertEqual((Ellipsis, slice(1, None, None)), subscript[..., 1:])
+        self.assertEqual((Ellipsis, slice(1, None, None)), subscript[..., 1::])
+        self.assertEqual((Ellipsis, slice(None, 1, 1)), subscript[..., :1:1])
+        self.assertEqual((Ellipsis, slice(None, 1, None)), subscript[..., :1:])
+        self.assertEqual((Ellipsis, slice(-1, -1, -1)), subscript[..., -1:-1:-1])
+        self.assertEqual((Ellipsis, slice(-1, -1, None)), subscript[..., -1:-1])
+        self.assertEqual((Ellipsis, slice(-1, None, -1)), subscript[..., -1::-1])
+        self.assertEqual((Ellipsis, slice(-1, None, None)), subscript[..., -1:])
+        self.assertEqual((Ellipsis, slice(-1, None, None)), subscript[..., -1::])
+        self.assertEqual((Ellipsis, slice(None, -1, -1)), subscript[..., :-1:-1])
+        self.assertEqual((Ellipsis, slice(1, -1, -1)), subscript[..., 1:-1:-1])
+        self.assertEqual((Ellipsis, slice(-1, 1, -1)), subscript[..., -1:1:-1])
+        self.assertEqual((Ellipsis, slice(-1, -1, 1)), subscript[..., -1:-1:1])
+        self.assertEqual((Ellipsis, slice(1, 1, -1)), subscript[..., 1:1:-1])
+        self.assertEqual((Ellipsis, slice(1, -1, 1)), subscript[..., 1:-1:1])
+        self.assertEqual((Ellipsis, slice(-1, 1, 1)), subscript[..., -1:1:1])
+        self.assertEqual((Ellipsis, slice(1, -1, None)), subscript[..., 1:-1])
+        self.assertEqual((Ellipsis, slice(1, -1, None)), subscript[..., 1:-1:])
+        self.assertEqual((Ellipsis, slice(-1, 1, None)), subscript[..., -1:1])
+        self.assertEqual((Ellipsis, slice(-1, 1, None)), subscript[..., -1:1:])
+        self.assertEqual((Ellipsis, slice(1, None, -1)), subscript[..., 1::-1])
+        self.assertEqual((Ellipsis, slice(-1, None, 1)), subscript[..., -1::1])
+        self.assertEqual((Ellipsis, slice(None, 1, -1)), subscript[..., :1:-1])
+        self.assertEqual((Ellipsis, slice(None, -1, 1)), subscript[..., :-1:1])
+        self.assertEqual((None, None), subscript[None, None])
+        self.assertEqual((None, ''), subscript[None, ''])
+        self.assertEqual((None, 5), subscript[None, 5])
+        self.assertEqual((None, slice(None, None, None)), subscript[None, :])
+        self.assertEqual((None, slice(None, None, None)), subscript[None, ::])
+        self.assertEqual((None, slice(1, 1, 1)), subscript[None, 1:1:1])
+        self.assertEqual((None, slice(1, 1, None)), subscript[None, 1:1])
+        self.assertEqual((None, slice(1, None, 1)), subscript[None, 1::1])
+        self.assertEqual((None, slice(1, None, None)), subscript[None, 1:])
+        self.assertEqual((None, slice(1, None, None)), subscript[None, 1::])
+        self.assertEqual((None, slice(None, 1, 1)), subscript[None, :1:1])
+        self.assertEqual((None, slice(None, 1, None)), subscript[None, :1:])
+        self.assertEqual((None, slice(None, 1, None)), subscript[None, :1:])
+        self.assertEqual((None, slice(-1, -1, -1)), subscript[None, -1:-1:-1])
+        self.assertEqual((None, slice(-1, -1, None)), subscript[None, -1:-1])
+        self.assertEqual((None, slice(-1, -1, None)), subscript[None, -1:-1:])
+        self.assertEqual((None, slice(-1, None, -1)), subscript[None, -1::-1])
+        self.assertEqual((None, slice(-1, None, None)), subscript[None, -1:])
+        self.assertEqual((None, slice(-1, None, None)), subscript[None, -1::])
+        self.assertEqual((None, slice(None, -1, -1)), subscript[None, :-1:-1])
+        self.assertEqual((None, slice(None, -1, None)), subscript[None, :-1])
+        self.assertEqual((None, slice(None, -1, None)), subscript[None, :-1:])
+        self.assertEqual((None, slice(1, -1, -1)), subscript[None, 1:-1:-1])
+        self.assertEqual((None, slice(-1, 1, -1)), subscript[None, -1:1:-1])
+        self.assertEqual((None, slice(-1, -1, 1)), subscript[None, -1:-1:1])
+        self.assertEqual((None, slice(1, 1, -1)), subscript[None, 1:1:-1])
+        self.assertEqual((None, slice(1, -1, 1)), subscript[None, 1:-1:1])
+        self.assertEqual((None, slice(-1, 1, 1)), subscript[None, -1:1:1])
+        self.assertEqual((None, slice(1, -1, None)), subscript[None, 1:-1])
+        self.assertEqual((None, slice(1, -1, None)), subscript[None, 1:-1:])
+        self.assertEqual((None, slice(-1, 1, None)), subscript[None, -1:1])
+        self.assertEqual((None, slice(-1, 1, None)), subscript[None, -1:1:])
+        self.assertEqual((None, slice(1, None, -1)), subscript[None, 1::-1])
+        self.assertEqual((None, slice(-1, None, 1)), subscript[None, -1::1])
+        self.assertEqual((None, slice(None, 1, -1)), subscript[None, :1:-1])
+        self.assertEqual((None, slice(None, -1, 1)), subscript[None, :-1:1])
+        self.assertEqual(('', None), subscript['', None])
+        self.assertEqual(('', ''), subscript['' ,''])
+        self.assertEqual(('', 5), subscript['', 5])
+        self.assertEqual(('', slice(None, None, None)), subscript['', :])
+        self.assertEqual(('', slice(1, 1, 1)), subscript['', 1:1:1])
+        self.assertEqual(('', slice(1, 1, None)), subscript['', 1:1])
+        self.assertEqual(('', slice(1, 1, None)), subscript['', 1:1:])
+        self.assertEqual(('', slice(1, None, 1)), subscript['', 1::1])
+        self.assertEqual(('', slice(1, None, None)), subscript['', 1:])
+        self.assertEqual(('', slice(1, None, None)), subscript['', 1::])
+        self.assertEqual(('', slice(None, 1, 1)), subscript['', :1:1])
+        self.assertEqual(('', slice(None, 1, None)), subscript['', :1])
+        self.assertEqual(('', slice(None, 1, None)), subscript['', :1:])
+        self.assertEqual(('', slice(-1, -1, -1)), subscript['', -1:-1:-1])
+        self.assertEqual(('', slice(-1, -1, None)), subscript['', -1:-1])
+        self.assertEqual(('', slice(-1, -1, None)), subscript['', -1:-1:])
+        self.assertEqual(('', slice(-1, None, -1)), subscript['', -1::-1])
+        self.assertEqual(('', slice(-1, None, None)), subscript['', -1:])
+        self.assertEqual(('', slice(-1, None, None)), subscript['', -1::])
+        self.assertEqual(('', slice(None, -1, -1)), subscript['', :-1:-1])
+        self.assertEqual(('', slice(None, -1, None)), subscript['', :-1])
+        self.assertEqual(('', slice(None, -1, None)), subscript['', :-1:])
+        self.assertEqual(('', slice(1, -1, -1)), subscript['', 1:-1:-1])
+        self.assertEqual(('', slice(-1, 1, -1)), subscript['', -1:1:-1])
+        self.assertEqual(('', slice(-1, -1, 1)), subscript['', -1:-1:1])
+        self.assertEqual(('', slice(1, 1, -1)), subscript['', 1:1:-1])
+        self.assertEqual(('', slice(1, -1, 1)), subscript['', 1:-1:1])
+        self.assertEqual(('', slice(-1, 1, 1)), subscript['', -1:1:1])
+        self.assertEqual(('', slice(1, -1, None)), subscript['', 1:-1])
+        self.assertEqual(('', slice(1, -1, None)), subscript['', 1:-1:])
+        self.assertEqual(('', slice(-1, 1, None)), subscript['', -1:1])
+        self.assertEqual(('', slice(-1, 1, None)), subscript['', -1:1:])
+        self.assertEqual(('', slice(1, None, -1)), subscript['', 1::-1])
+        self.assertEqual(('', slice(-1, None, 1)), subscript['', -1::1])
+        self.assertEqual(('', slice(None, 1, -1)), subscript['', :1:-1])
+        self.assertEqual(('', slice(None, -1, 1)), subscript['', :-1:1])
+        self.assertEqual((5, None), subscript[5, None])
+        self.assertEqual((5, ''), subscript[5 ,''])
+        self.assertEqual((5, 5), subscript[5, 5])
+        self.assertEqual((5, slice(None, None, None)), subscript[5, :])
+        self.assertEqual((5, slice(1, 1, 1)), subscript[5, 1:1:1])
+        self.assertEqual((5, slice(1, 1, None)), subscript[5, 1:1])
+        self.assertEqual((5, slice(1, 1, None)), subscript[5, 1:1:])
+        self.assertEqual((5, slice(1, None, 1)), subscript[5, 1::1])
+        self.assertEqual((5, slice(1, None, None)), subscript[5, 1:])
+        self.assertEqual((5, slice(1, None, None)), subscript[5, 1::])
+        self.assertEqual((5, slice(None, 1, 1)), subscript[5, :1:1])
+        self.assertEqual((5, slice(None, 1, None)), subscript[5, :1])
+        self.assertEqual((5, slice(None, 1, None)), subscript[5, :1:])
+        self.assertEqual((5, slice(-1, -1, -1)), subscript[5, -1:-1:-1])
+        self.assertEqual((5, slice(-1, -1, None)), subscript[5, -1:-1])
+        self.assertEqual((5, slice(-1, -1, None)), subscript[5, -1:-1:])
+        self.assertEqual((5, slice(-1, None, -1)), subscript[5, -1::-1])
+        self.assertEqual((5, slice(-1, None, None)), subscript[5, -1:])
+        self.assertEqual((5, slice(-1, None, None)), subscript[5, -1::])
+        self.assertEqual((5, slice(None, -1, -1)), subscript[5, :-1:-1])
+        self.assertEqual((5, slice(None, -1, None)), subscript[5, :-1])
+        self.assertEqual((5, slice(None, -1, None)), subscript[5, :-1:])
+        self.assertEqual((5, slice(1, -1, -1)), subscript[5, 1:-1:-1])
+        self.assertEqual((5, slice(-1, 1, -1)), subscript[5, -1:1:-1])
+        self.assertEqual((5, slice(-1, -1, 1)), subscript[5, -1:-1:1])
+        self.assertEqual((5, slice(1, 1, -1)), subscript[5, 1:1:-1])
+        self.assertEqual((5, slice(1, -1, 1)), subscript[5, 1:-1:1])
+        self.assertEqual((5, slice(-1, 1, 1)), subscript[5, -1:1:1])
+        self.assertEqual((5, slice(1, -1, None)), subscript[5, 1:-1])
+        self.assertEqual((5, slice(1, -1, None)), subscript[5, 1:-1:])
+        self.assertEqual((5, slice(-1, 1, None)), subscript[5, -1:1])
+        self.assertEqual((5, slice(-1, 1, None)), subscript[5, -1:1:])
+        self.assertEqual((5, slice(1, None, -1)), subscript[5, 1::-1])
+        self.assertEqual((5, slice(-1, None, 1)), subscript[5, -1::1])
+        self.assertEqual((5, slice(None, 1, -1)), subscript[5, :1:-1])
+        self.assertEqual((5, slice(None, -1, 1)), subscript[5, :-1:1])
+        self.assertEqual((slice(None, None, None), None), subscript[:, None])
+        self.assertEqual((slice(None, None, None), ''), subscript[: ,''])
+        self.assertEqual((slice(None, None, None), 5), subscript[:, 5])
+        self.assertEqual((slice(None, None, None), slice(None, None, None)), subscript[:, :])
+        self.assertEqual((slice(None, None, None), slice(1, 1, 1)), subscript[:, 1:1:1])
+        self.assertEqual((slice(None, None, None), slice(1, 1, None)), subscript[:, 1:1])
+        self.assertEqual((slice(None, None, None), slice(1, 1, None)), subscript[:, 1:1:])
+        self.assertEqual((slice(None, None, None), slice(1, None, 1)), subscript[:, 1::1])
+        self.assertEqual((slice(None, None, None), slice(1, None, None)), subscript[:, 1:])
+        self.assertEqual((slice(None, None, None), slice(1, None, None)), subscript[:, 1::])
+        self.assertEqual((slice(None, None, None), slice(None, 1, 1)), subscript[:, :1:1])
+        self.assertEqual((slice(None, None, None), slice(None, 1, None)), subscript[:, :1])
+        self.assertEqual((slice(None, None, None), slice(None, 1, None)), subscript[:, :1:])
+        self.assertEqual((slice(None, None, None), slice(-1, -1, -1)), subscript[:, -1:-1:-1])
+        self.assertEqual((slice(None, None, None), slice(-1, -1, None)), subscript[:, -1:-1])
+        self.assertEqual((slice(None, None, None), slice(-1, -1, None)), subscript[:, -1:-1:])
+        self.assertEqual((slice(None, None, None), slice(-1, None, -1)), subscript[:, -1::-1])
+        self.assertEqual((slice(None, None, None), slice(-1, None, None)), subscript[:, -1:])
+        self.assertEqual((slice(None, None, None), slice(-1, None, None)), subscript[:, -1::])
+        self.assertEqual((slice(None, None, None), slice(None, -1, -1)), subscript[:, :-1:-1])
+        self.assertEqual((slice(None, None, None), slice(None, -1, None)), subscript[:, :-1])
+        self.assertEqual((slice(None, None, None), slice(None, -1, None)), subscript[:, :-1:])
+        self.assertEqual((slice(None, None, None), slice(1, -1, -1)), subscript[:, 1:-1:-1])
+        self.assertEqual((slice(None, None, None), slice(-1, 1, -1)), subscript[:, -1:1:-1])
+        self.assertEqual((slice(None, None, None), slice(-1, -1, 1)), subscript[:, -1:-1:1])
+        self.assertEqual((slice(None, None, None), slice(1, 1, -1)), subscript[:, 1:1:-1])
+        self.assertEqual((slice(None, None, None), slice(1, -1, 1)), subscript[:, 1:-1:1])
+        self.assertEqual((slice(None, None, None), slice(-1, 1, 1)), subscript[:, -1:1:1])
+        self.assertEqual((slice(None, None, None), slice(1, -1, None)), subscript[:, 1:-1])
+        self.assertEqual((slice(None, None, None), slice(1, -1, None)), subscript[:, 1:-1:])
+        self.assertEqual((slice(None, None, None), slice(-1, 1, None)), subscript[:, -1:1])
+        self.assertEqual((slice(None, None, None), slice(-1, 1, None)), subscript[:, -1:1:])
+        self.assertEqual((slice(None, None, None), slice(1, None, -1)), subscript[:, 1::-1])
+        self.assertEqual((slice(None, None, None), slice(-1, None, 1)), subscript[:, -1::1])
+        self.assertEqual((slice(None, None, None), slice(None, 1, -1)), subscript[:, :1:-1])
+        self.assertEqual((slice(None, None, None), slice(None, -1, 1)), subscript[:, :-1:1])
+        self.assertEqual((slice(1, 1, 1), None), subscript[1:1:1, None])
+        self.assertEqual((slice(1, 1, 1), ''), subscript[1:1:1 ,''])
+        self.assertEqual((slice(1, 1, 1), 5), subscript[1:1:1, 5])
+        self.assertEqual((slice(1, 1, 1), slice(None, None, None)), subscript[1:1:1, :])
+        self.assertEqual((slice(1, 1, 1), slice(1, 1, 1)), subscript[1:1:1, 1:1:1])
+        self.assertEqual((slice(1, 1, 1), slice(1, 1, None)), subscript[1:1:1, 1:1])
+        self.assertEqual((slice(1, 1, 1), slice(1, 1, None)), subscript[1:1:1, 1:1:])
+        self.assertEqual((slice(1, 1, 1), slice(1, None, 1)), subscript[1:1:1, 1::1])
+        self.assertEqual((slice(1, 1, 1), slice(1, None, None)), subscript[1:1:1, 1:])
+        self.assertEqual((slice(1, 1, 1), slice(1, None, None)), subscript[1:1:1, 1::])
+        self.assertEqual((slice(1, 1, 1), slice(None, 1, 1)), subscript[1:1:1, :1:1])
+        self.assertEqual((slice(1, 1, 1), slice(None, 1, None)), subscript[1:1:1, :1])
+        self.assertEqual((slice(1, 1, 1), slice(None, 1, None)), subscript[1:1:1, :1:])
+        self.assertEqual((slice(1, 1, 1), slice(-1, -1, -1)), subscript[1:1:1, -1:-1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, -1, None)), subscript[1:1:1, -1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, -1, None)), subscript[1:1:1, -1:-1:])
+        self.assertEqual((slice(1, 1, 1), slice(-1, None, -1)), subscript[1:1:1, -1::-1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, None, None)), subscript[1:1:1, -1:])
+        self.assertEqual((slice(1, 1, 1), slice(-1, None, None)), subscript[1:1:1, -1::])
+        self.assertEqual((slice(1, 1, 1), slice(None, -1, -1)), subscript[1:1:1, :-1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(None, -1, None)), subscript[1:1:1, :-1])
+        self.assertEqual((slice(1, 1, 1), slice(None, -1, None)), subscript[1:1:1, :-1:])
+        self.assertEqual((slice(1, 1, 1), slice(1, -1, -1)), subscript[1:1:1, 1:-1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, 1, -1)), subscript[1:1:1, -1:1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, -1, 1)), subscript[1:1:1, -1:-1:1])
+        self.assertEqual((slice(1, 1, 1), slice(1, 1, -1)), subscript[1:1:1, 1:1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(1, -1, 1)), subscript[1:1:1, 1:-1:1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, 1, 1)), subscript[1:1:1, -1:1:1])
+        self.assertEqual((slice(1, 1, 1), slice(1, -1, None)), subscript[1:1:1, 1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(1, -1, None)), subscript[1:1:1, 1:-1:])
+        self.assertEqual((slice(1, 1, 1), slice(-1, 1, None)), subscript[1:1:1, -1:1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, 1, None)), subscript[1:1:1, -1:1:])
+        self.assertEqual((slice(1, 1, 1), slice(1, None, -1)), subscript[1:1:1, 1::-1])
+        self.assertEqual((slice(1, 1, 1), slice(-1, None, 1)), subscript[1:1:1, -1::1])
+        self.assertEqual((slice(1, 1, 1), slice(None, 1, -1)), subscript[1:1:1, :1:-1])
+        self.assertEqual((slice(1, 1, 1), slice(None, -1, 1)), subscript[1:1:1, :-1:1])
+        self.assertEqual((slice(1, 1, None), None), subscript[1:1, None])
+        self.assertEqual((slice(1, 1, None), ''), subscript[1:1 ,''])
+        self.assertEqual((slice(1, 1, None), 5), subscript[1:1, 5])
+        self.assertEqual((slice(1, 1, None), slice(None, None, None)), subscript[1:1, :])
+        self.assertEqual((slice(1, 1, None), slice(1, 1, 1)), subscript[1:1, 1:1:1])
+        self.assertEqual((slice(1, 1, None), slice(1, 1, None)), subscript[1:1, 1:1])
+        self.assertEqual((slice(1, 1, None), slice(1, 1, None)), subscript[1:1, 1:1:])
+        self.assertEqual((slice(1, 1, None), slice(1, None, 1)), subscript[1:1, 1::1])
+        self.assertEqual((slice(1, 1, None), slice(1, None, None)), subscript[1:1, 1:])
+        self.assertEqual((slice(1, 1, None), slice(1, None, None)), subscript[1:1, 1::])
+        self.assertEqual((slice(1, 1, None), slice(None, 1, 1)), subscript[1:1, :1:1])
+        self.assertEqual((slice(1, 1, None), slice(None, 1, None)), subscript[1:1, :1])
+        self.assertEqual((slice(1, 1, None), slice(None, 1, None)), subscript[1:1, :1:])
+        self.assertEqual((slice(1, 1, None), slice(-1, -1, -1)), subscript[1:1, -1:-1:-1])
+        self.assertEqual((slice(1, 1, None), slice(-1, -1, None)), subscript[1:1, -1:-1])
+        self.assertEqual((slice(1, 1, None), slice(-1, -1, None)), subscript[1:1, -1:-1:])
+        self.assertEqual((slice(1, 1, None), slice(-1, None, -1)), subscript[1:1, -1::-1])
+        self.assertEqual((slice(1, 1, None), slice(-1, None, None)), subscript[1:1, -1:])
+        self.assertEqual((slice(1, 1, None), slice(-1, None, None)), subscript[1:1, -1::])
+        self.assertEqual((slice(1, 1, None), slice(None, -1, -1)), subscript[1:1, :-1:-1])
+        self.assertEqual((slice(1, 1, None), slice(None, -1, None)), subscript[1:1, :-1])
+        self.assertEqual((slice(1, 1, None), slice(None, -1, None)), subscript[1:1, :-1:])
+        self.assertEqual((slice(1, 1, None), slice(1, -1, -1)), subscript[1:1, 1:-1:-1])
+        self.assertEqual((slice(1, 1, None), slice(-1, 1, -1)), subscript[1:1, -1:1:-1])
+        self.assertEqual((slice(1, 1, None), slice(-1, -1, 1)), subscript[1:1, -1:-1:1])
+        self.assertEqual((slice(1, 1, None), slice(1, 1, -1)), subscript[1:1, 1:1:-1])
+        self.assertEqual((slice(1, 1, None), slice(1, -1, 1)), subscript[1:1, 1:-1:1])
+        self.assertEqual((slice(1, 1, None), slice(-1, 1, 1)), subscript[1:1, -1:1:1])
+        self.assertEqual((slice(1, 1, None), slice(1, -1, None)), subscript[1:1, 1:-1])
+        self.assertEqual((slice(1, 1, None), slice(1, -1, None)), subscript[1:1, 1:-1:])
+        self.assertEqual((slice(1, 1, None), slice(-1, 1, None)), subscript[1:1, -1:1])
+        self.assertEqual((slice(1, 1, None), slice(-1, 1, None)), subscript[1:1, -1:1:])
+        self.assertEqual((slice(1, 1, None), slice(1, None, -1)), subscript[1:1, 1::-1])
+        self.assertEqual((slice(1, 1, None), slice(-1, None, 1)), subscript[1:1, -1::1])
+        self.assertEqual((slice(1, 1, None), slice(None, 1, -1)), subscript[1:1, :1:-1])
+        self.assertEqual((slice(1, 1, None), slice(None, -1, 1)), subscript[1:1, :-1:1])
+        self.assertEqual((slice(1, None, None), None), subscript[1:, None])
+        self.assertEqual((slice(1, None, None), ''), subscript[1: ,''])
+        self.assertEqual((slice(1, None, None), 5), subscript[1:, 5])
+        self.assertEqual((slice(1, None, None), slice(None, None, None)), subscript[1:, :])
+        self.assertEqual((slice(1, None, None), slice(1, 1, 1)), subscript[1:, 1:1:1])
+        self.assertEqual((slice(1, None, None), slice(1, 1, None)), subscript[1:, 1:1])
+        self.assertEqual((slice(1, None, None), slice(1, 1, None)), subscript[1:, 1:1:])
+        self.assertEqual((slice(1, None, None), slice(1, None, 1)), subscript[1:, 1::1])
+        self.assertEqual((slice(1, None, None), slice(1, None, None)), subscript[1:, 1:])
+        self.assertEqual((slice(1, None, None), slice(1, None, None)), subscript[1:, 1::])
+        self.assertEqual((slice(1, None, None), slice(None, 1, 1)), subscript[1:, :1:1])
+        self.assertEqual((slice(1, None, None), slice(None, 1, None)), subscript[1:, :1])
+        self.assertEqual((slice(1, None, None), slice(None, 1, None)), subscript[1:, :1:])
+        self.assertEqual((slice(1, None, None), slice(-1, -1, -1)), subscript[1:, -1:-1:-1])
+        self.assertEqual((slice(1, None, None), slice(-1, -1, None)), subscript[1:, -1:-1])
+        self.assertEqual((slice(1, None, None), slice(-1, -1, None)), subscript[1:, -1:-1:])
+        self.assertEqual((slice(1, None, None), slice(-1, None, -1)), subscript[1:, -1::-1])
+        self.assertEqual((slice(1, None, None), slice(-1, None, None)), subscript[1:, -1:])
+        self.assertEqual((slice(1, None, None), slice(-1, None, None)), subscript[1:, -1::])
+        self.assertEqual((slice(1, None, None), slice(None, -1, -1)), subscript[1:, :-1:-1])
+        self.assertEqual((slice(1, None, None), slice(None, -1, None)), subscript[1:, :-1])
+        self.assertEqual((slice(1, None, None), slice(None, -1, None)), subscript[1:, :-1:])
+        self.assertEqual((slice(1, None, None), slice(1, -1, -1)), subscript[1:, 1:-1:-1])
+        self.assertEqual((slice(1, None, None), slice(-1, 1, -1)), subscript[1:, -1:1:-1])
+        self.assertEqual((slice(1, None, None), slice(-1, -1, 1)), subscript[1:, -1:-1:1])
+        self.assertEqual((slice(1, None, None), slice(1, 1, -1)), subscript[1:, 1:1:-1])
+        self.assertEqual((slice(1, None, None), slice(1, -1, 1)), subscript[1:, 1:-1:1])
+        self.assertEqual((slice(1, None, None), slice(-1, 1, 1)), subscript[1:, -1:1:1])
+        self.assertEqual((slice(1, None, None), slice(1, -1, None)), subscript[1:, 1:-1])
+        self.assertEqual((slice(1, None, None), slice(1, -1, None)), subscript[1:, 1:-1:])
+        self.assertEqual((slice(1, None, None), slice(-1, 1, None)), subscript[1:, -1:1])
+        self.assertEqual((slice(1, None, None), slice(-1, 1, None)), subscript[1:, -1:1:])
+        self.assertEqual((slice(1, None, None), slice(1, None, -1)), subscript[1:, 1::-1])
+        self.assertEqual((slice(1, None, None), slice(-1, None, 1)), subscript[1:, -1::1])
+        self.assertEqual((slice(1, None, None), slice(None, 1, -1)), subscript[1:, :1:-1])
+        self.assertEqual((slice(1, None, None), slice(None, -1, 1)), subscript[1:, :-1:1])
+        self.assertEqual((slice(None, 1, 1), None), subscript[:1:1, None])
+        self.assertEqual((slice(None, 1, 1), ''), subscript[:1:1 ,''])
+        self.assertEqual((slice(None, 1, 1), 5), subscript[:1:1, 5])
+        self.assertEqual((slice(None, 1, 1), slice(None, None, None)), subscript[:1:1, :])
+        self.assertEqual((slice(None, 1, 1), slice(1, 1, 1)), subscript[:1:1, 1:1:1])
+        self.assertEqual((slice(None, 1, 1), slice(1, 1, None)), subscript[:1:1, 1:1])
+        self.assertEqual((slice(None, 1, 1), slice(1, 1, None)), subscript[:1:1, 1:1:])
+        self.assertEqual((slice(None, 1, 1), slice(1, None, 1)), subscript[:1:1, 1::1])
+        self.assertEqual((slice(None, 1, 1), slice(1, None, None)), subscript[:1:1, 1:])
+        self.assertEqual((slice(None, 1, 1), slice(1, None, None)), subscript[:1:1, 1::])
+        self.assertEqual((slice(None, 1, 1), slice(None, 1, 1)), subscript[:1:1, :1:1])
+        self.assertEqual((slice(None, 1, 1), slice(None, 1, None)), subscript[:1:1, :1])
+        self.assertEqual((slice(None, 1, 1), slice(None, 1, None)), subscript[:1:1, :1:])
+        self.assertEqual((slice(None, 1, 1), slice(-1, -1, -1)), subscript[:1:1, -1:-1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, -1, None)), subscript[:1:1, -1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, -1, None)), subscript[:1:1, -1:-1:])
+        self.assertEqual((slice(None, 1, 1), slice(-1, None, -1)), subscript[:1:1, -1::-1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, None, None)), subscript[:1:1, -1:])
+        self.assertEqual((slice(None, 1, 1), slice(-1, None, None)), subscript[:1:1, -1::])
+        self.assertEqual((slice(None, 1, 1), slice(None, -1, -1)), subscript[:1:1, :-1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(None, -1, None)), subscript[:1:1, :-1])
+        self.assertEqual((slice(None, 1, 1), slice(None, -1, None)), subscript[:1:1, :-1:])
+        self.assertEqual((slice(None, 1, 1), slice(1, -1, -1)), subscript[:1:1, 1:-1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, 1, -1)), subscript[:1:1, -1:1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, -1, 1)), subscript[:1:1, -1:-1:1])
+        self.assertEqual((slice(None, 1, 1), slice(1, 1, -1)), subscript[:1:1, 1:1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(1, -1, 1)), subscript[:1:1, 1:-1:1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, 1, 1)), subscript[:1:1, -1:1:1])
+        self.assertEqual((slice(None, 1, 1), slice(1, -1, None)), subscript[:1:1, 1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(1, -1, None)), subscript[:1:1, 1:-1:])
+        self.assertEqual((slice(None, 1, 1), slice(-1, 1, None)), subscript[:1:1, -1:1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, 1, None)), subscript[:1:1, -1:1:])
+        self.assertEqual((slice(None, 1, 1), slice(1, None, -1)), subscript[:1:1, 1::-1])
+        self.assertEqual((slice(None, 1, 1), slice(-1, None, 1)), subscript[:1:1, -1::1])
+        self.assertEqual((slice(None, 1, 1), slice(None, 1, -1)), subscript[:1:1, :1:-1])
+        self.assertEqual((slice(None, 1, 1), slice(None, -1, 1)), subscript[:1:1, :-1:1])
+        self.assertEqual((slice(None, 1, None), None), subscript[:1, None])
+        self.assertEqual((slice(None, 1, None), ''), subscript[:1 ,''])
+        self.assertEqual((slice(None, 1, None), 5), subscript[:1, 5])
+        self.assertEqual((slice(None, 1, None), slice(None, None, None)), subscript[:1, :])
+        self.assertEqual((slice(None, 1, None), slice(1, 1, 1)), subscript[:1, 1:1:1])
+        self.assertEqual((slice(None, 1, None), slice(1, 1, None)), subscript[:1, 1:1])
+        self.assertEqual((slice(None, 1, None), slice(1, 1, None)), subscript[:1, 1:1:])
+        self.assertEqual((slice(None, 1, None), slice(1, None, 1)), subscript[:1, 1::1])
+        self.assertEqual((slice(None, 1, None), slice(1, None, None)), subscript[:1, 1:])
+        self.assertEqual((slice(None, 1, None), slice(1, None, None)), subscript[:1, 1::])
+        self.assertEqual((slice(None, 1, None), slice(None, 1, 1)), subscript[:1, :1:1])
+        self.assertEqual((slice(None, 1, None), slice(None, 1, None)), subscript[:1, :1])
+        self.assertEqual((slice(None, 1, None), slice(None, 1, None)), subscript[:1, :1:])
+        self.assertEqual((slice(None, 1, None), slice(-1, -1, -1)), subscript[:1, -1:-1:-1])
+        self.assertEqual((slice(None, 1, None), slice(-1, -1, None)), subscript[:1, -1:-1])
+        self.assertEqual((slice(None, 1, None), slice(-1, -1, None)), subscript[:1, -1:-1:])
+        self.assertEqual((slice(None, 1, None), slice(-1, None, -1)), subscript[:1, -1::-1])
+        self.assertEqual((slice(None, 1, None), slice(-1, None, None)), subscript[:1, -1:])
+        self.assertEqual((slice(None, 1, None), slice(-1, None, None)), subscript[:1, -1::])
+        self.assertEqual((slice(None, 1, None), slice(None, -1, -1)), subscript[:1, :-1:-1])
+        self.assertEqual((slice(None, 1, None), slice(None, -1, None)), subscript[:1, :-1])
+        self.assertEqual((slice(None, 1, None), slice(None, -1, None)), subscript[:1, :-1:])
+        self.assertEqual((slice(None, 1, None), slice(1, -1, -1)), subscript[:1, 1:-1:-1])
+        self.assertEqual((slice(None, 1, None), slice(-1, 1, -1)), subscript[:1, -1:1:-1])
+        self.assertEqual((slice(None, 1, None), slice(-1, -1, 1)), subscript[:1, -1:-1:1])
+        self.assertEqual((slice(None, 1, None), slice(1, 1, -1)), subscript[:1, 1:1:-1])
+        self.assertEqual((slice(None, 1, None), slice(1, -1, 1)), subscript[:1, 1:-1:1])
+        self.assertEqual((slice(None, 1, None), slice(-1, 1, 1)), subscript[:1, -1:1:1])
+        self.assertEqual((slice(None, 1, None), slice(1, -1, None)), subscript[:1, 1:-1])
+        self.assertEqual((slice(None, 1, None), slice(1, -1, None)), subscript[:1, 1:-1:])
+        self.assertEqual((slice(None, 1, None), slice(-1, 1, None)), subscript[:1, -1:1])
+        self.assertEqual((slice(None, 1, None), slice(-1, 1, None)), subscript[:1, -1:1:])
+        self.assertEqual((slice(None, 1, None), slice(1, None, -1)), subscript[:1, 1::-1])
+        self.assertEqual((slice(None, 1, None), slice(-1, None, 1)), subscript[:1, -1::1])
+        self.assertEqual((slice(None, 1, None), slice(None, 1, -1)), subscript[:1, :1:-1])
+        self.assertEqual((slice(None, 1, None), slice(None, -1, 1)), subscript[:1, :-1:1])
+        self.assertEqual((slice(-1, -1, -1), None), subscript[-1:-1:-1, None])
+        self.assertEqual((slice(-1, -1, -1), ''), subscript[-1:-1:-1 ,''])
+        self.assertEqual((slice(-1, -1, -1), 5), subscript[-1:-1:-1, 5])
+        self.assertEqual((slice(-1, -1, -1), slice(None, None, None)), subscript[-1:-1:-1, :])
+        self.assertEqual((slice(-1, -1, -1), slice(1, 1, 1)), subscript[-1:-1:-1, 1:1:1])
+        self.assertEqual((slice(-1, -1, -1), slice(1, 1, None)), subscript[-1:-1:-1, 1:1])
+        self.assertEqual((slice(-1, -1, -1), slice(1, 1, None)), subscript[-1:-1:-1, 1:1:])
+        self.assertEqual((slice(-1, -1, -1), slice(1, None, 1)), subscript[-1:-1:-1, 1::1])
+        self.assertEqual((slice(-1, -1, -1), slice(1, None, None)), subscript[-1:-1:-1, 1:])
+        self.assertEqual((slice(-1, -1, -1), slice(1, None, None)), subscript[-1:-1:-1, 1::])
+        self.assertEqual((slice(-1, -1, -1), slice(None, 1, 1)), subscript[-1:-1:-1, :1:1])
+        self.assertEqual((slice(-1, -1, -1), slice(None, 1, None)), subscript[-1:-1:-1, :1])
+        self.assertEqual((slice(-1, -1, -1), slice(None, 1, None)), subscript[-1:-1:-1, :1:])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, -1, -1)), subscript[-1:-1:-1, -1:-1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, -1, None)), subscript[-1:-1:-1, -1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, -1, None)), subscript[-1:-1:-1, -1:-1:])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, None, -1)), subscript[-1:-1:-1, -1::-1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, None, None)), subscript[-1:-1:-1, -1:])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, None, None)), subscript[-1:-1:-1, -1::])
+        self.assertEqual((slice(-1, -1, -1), slice(None, -1, -1)), subscript[-1:-1:-1, :-1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(None, -1, None)), subscript[-1:-1:-1, :-1])
+        self.assertEqual((slice(-1, -1, -1), slice(None, -1, None)), subscript[-1:-1:-1, :-1:])
+        self.assertEqual((slice(-1, -1, -1), slice(1, -1, -1)), subscript[-1:-1:-1, 1:-1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, 1, -1)), subscript[-1:-1:-1, -1:1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, -1, 1)), subscript[-1:-1:-1, -1:-1:1])
+        self.assertEqual((slice(-1, -1, -1), slice(1, 1, -1)), subscript[-1:-1:-1, 1:1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(1, -1, 1)), subscript[-1:-1:-1, 1:-1:1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, 1, 1)), subscript[-1:-1:-1, -1:1:1])
+        self.assertEqual((slice(-1, -1, -1), slice(1, -1, None)), subscript[-1:-1:-1, 1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(1, -1, None)), subscript[-1:-1:-1, 1:-1:])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, 1, None)), subscript[-1:-1:-1, -1:1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, 1, None)), subscript[-1:-1:-1, -1:1:])
+        self.assertEqual((slice(-1, -1, -1), slice(1, None, -1)), subscript[-1:-1:-1, 1::-1])
+        self.assertEqual((slice(-1, -1, -1), slice(-1, None, 1)), subscript[-1:-1:-1, -1::1])
+        self.assertEqual((slice(-1, -1, -1), slice(None, 1, -1)), subscript[-1:-1:-1, :1:-1])
+        self.assertEqual((slice(-1, -1, -1), slice(None, -1, 1)), subscript[-1:-1:-1, :-1:1])
+        self.assertEqual((slice(-1, -1, None), None), subscript[-1:-1, None])
+        self.assertEqual((slice(-1, -1, None), ''), subscript[-1:-1 ,''])
+        self.assertEqual((slice(-1, -1, None), 5), subscript[-1:-1, 5])
+        self.assertEqual((slice(-1, -1, None), slice(None, None, None)), subscript[-1:-1, :])
+        self.assertEqual((slice(-1, -1, None), slice(1, 1, 1)), subscript[-1:-1, 1:1:1])
+        self.assertEqual((slice(-1, -1, None), slice(1, 1, None)), subscript[-1:-1, 1:1])
+        self.assertEqual((slice(-1, -1, None), slice(1, 1, None)), subscript[-1:-1, 1:1:])
+        self.assertEqual((slice(-1, -1, None), slice(1, None, 1)), subscript[-1:-1, 1::1])
+        self.assertEqual((slice(-1, -1, None), slice(1, None, None)), subscript[-1:-1, 1:])
+        self.assertEqual((slice(-1, -1, None), slice(1, None, None)), subscript[-1:-1, 1::])
+        self.assertEqual((slice(-1, -1, None), slice(None, 1, 1)), subscript[-1:-1, :1:1])
+        self.assertEqual((slice(-1, -1, None), slice(None, 1, None)), subscript[-1:-1, :1])
+        self.assertEqual((slice(-1, -1, None), slice(None, 1, None)), subscript[-1:-1, :1:])
+        self.assertEqual((slice(-1, -1, None), slice(-1, -1, -1)), subscript[-1:-1, -1:-1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, -1, None)), subscript[-1:-1, -1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, -1, None)), subscript[-1:-1, -1:-1:])
+        self.assertEqual((slice(-1, -1, None), slice(-1, None, -1)), subscript[-1:-1, -1::-1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, None, None)), subscript[-1:-1, -1:])
+        self.assertEqual((slice(-1, -1, None), slice(-1, None, None)), subscript[-1:-1, -1::])
+        self.assertEqual((slice(-1, -1, None), slice(None, -1, -1)), subscript[-1:-1, :-1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(None, -1, None)), subscript[-1:-1, :-1])
+        self.assertEqual((slice(-1, -1, None), slice(None, -1, None)), subscript[-1:-1, :-1:])
+        self.assertEqual((slice(-1, -1, None), slice(1, -1, -1)), subscript[-1:-1, 1:-1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, 1, -1)), subscript[-1:-1, -1:1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, -1, 1)), subscript[-1:-1, -1:-1:1])
+        self.assertEqual((slice(-1, -1, None), slice(1, 1, -1)), subscript[-1:-1, 1:1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(1, -1, 1)), subscript[-1:-1, 1:-1:1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, 1, 1)), subscript[-1:-1, -1:1:1])
+        self.assertEqual((slice(-1, -1, None), slice(1, -1, None)), subscript[-1:-1, 1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(1, -1, None)), subscript[-1:-1, 1:-1:])
+        self.assertEqual((slice(-1, -1, None), slice(-1, 1, None)), subscript[-1:-1, -1:1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, 1, None)), subscript[-1:-1, -1:1:])
+        self.assertEqual((slice(-1, -1, None), slice(1, None, -1)), subscript[-1:-1, 1::-1])
+        self.assertEqual((slice(-1, -1, None), slice(-1, None, 1)), subscript[-1:-1, -1::1])
+        self.assertEqual((slice(-1, -1, None), slice(None, 1, -1)), subscript[-1:-1, :1:-1])
+        self.assertEqual((slice(-1, -1, None), slice(None, -1, 1)), subscript[-1:-1, :-1:1])
+        self.assertEqual((slice(-1, None, -1), None), subscript[-1::-1, None])
+        self.assertEqual((slice(-1, None, -1), ''), subscript[-1::-1 ,''])
+        self.assertEqual((slice(-1, None, -1), 5), subscript[-1::-1, 5])
+        self.assertEqual((slice(-1, None, -1), slice(None, None, None)), subscript[-1::-1, :])
+        self.assertEqual((slice(-1, None, -1), slice(1, 1, 1)), subscript[-1::-1, 1:1:1])
+        self.assertEqual((slice(-1, None, -1), slice(1, 1, None)), subscript[-1::-1, 1:1])
+        self.assertEqual((slice(-1, None, -1), slice(1, 1, None)), subscript[-1::-1, 1:1:])
+        self.assertEqual((slice(-1, None, -1), slice(1, None, 1)), subscript[-1::-1, 1::1])
+        self.assertEqual((slice(-1, None, -1), slice(1, None, None)), subscript[-1::-1, 1:])
+        self.assertEqual((slice(-1, None, -1), slice(1, None, None)), subscript[-1::-1, 1::])
+        self.assertEqual((slice(-1, None, -1), slice(None, 1, 1)), subscript[-1::-1, :1:1])
+        self.assertEqual((slice(-1, None, -1), slice(None, 1, None)), subscript[-1::-1, :1])
+        self.assertEqual((slice(-1, None, -1), slice(None, 1, None)), subscript[-1::-1, :1:])
+        self.assertEqual((slice(-1, None, -1), slice(-1, -1, -1)), subscript[-1::-1, -1:-1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, -1, None)), subscript[-1::-1, -1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, -1, None)), subscript[-1::-1, -1:-1:])
+        self.assertEqual((slice(-1, None, -1), slice(-1, None, -1)), subscript[-1::-1, -1::-1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, None, None)), subscript[-1::-1, -1:])
+        self.assertEqual((slice(-1, None, -1), slice(-1, None, None)), subscript[-1::-1, -1::])
+        self.assertEqual((slice(-1, None, -1), slice(None, -1, -1)), subscript[-1::-1, :-1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(None, -1, None)), subscript[-1::-1, :-1])
+        self.assertEqual((slice(-1, None, -1), slice(None, -1, None)), subscript[-1::-1, :-1:])
+        self.assertEqual((slice(-1, None, -1), slice(1, -1, -1)), subscript[-1::-1, 1:-1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, 1, -1)), subscript[-1::-1, -1:1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, -1, 1)), subscript[-1::-1, -1:-1:1])
+        self.assertEqual((slice(-1, None, -1), slice(1, 1, -1)), subscript[-1::-1, 1:1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(1, -1, 1)), subscript[-1::-1, 1:-1:1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, 1, 1)), subscript[-1::-1, -1:1:1])
+        self.assertEqual((slice(-1, None, -1), slice(1, -1, None)), subscript[-1::-1, 1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(1, -1, None)), subscript[-1::-1, 1:-1:])
+        self.assertEqual((slice(-1, None, -1), slice(-1, 1, None)), subscript[-1::-1, -1:1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, 1, None)), subscript[-1::-1, -1:1:])
+        self.assertEqual((slice(-1, None, -1), slice(1, None, -1)), subscript[-1::-1, 1::-1])
+        self.assertEqual((slice(-1, None, -1), slice(-1, None, 1)), subscript[-1::-1, -1::1])
+        self.assertEqual((slice(-1, None, -1), slice(None, 1, -1)), subscript[-1::-1, :1:-1])
+        self.assertEqual((slice(-1, None, -1), slice(None, -1, 1)), subscript[-1::-1, :-1:1])
+        self.assertEqual((slice(-1, None, None), None), subscript[-1:, None])
+        self.assertEqual((slice(-1, None, None), ''), subscript[-1: ,''])
+        self.assertEqual((slice(-1, None, None), 5), subscript[-1:, 5])
+        self.assertEqual((slice(-1, None, None), slice(None, None, None)), subscript[-1:, :])
+        self.assertEqual((slice(-1, None, None), slice(1, 1, 1)), subscript[-1:, 1:1:1])
+        self.assertEqual((slice(-1, None, None), slice(1, 1, None)), subscript[-1:, 1:1])
+        self.assertEqual((slice(-1, None, None), slice(1, 1, None)), subscript[-1:, 1:1:])
+        self.assertEqual((slice(-1, None, None), slice(1, None, 1)), subscript[-1:, 1::1])
+        self.assertEqual((slice(-1, None, None), slice(1, None, None)), subscript[-1:, 1:])
+        self.assertEqual((slice(-1, None, None), slice(1, None, None)), subscript[-1:, 1::])
+        self.assertEqual((slice(-1, None, None), slice(None, 1, 1)), subscript[-1:, :1:1])
+        self.assertEqual((slice(-1, None, None), slice(None, 1, None)), subscript[-1:, :1])
+        self.assertEqual((slice(-1, None, None), slice(None, 1, None)), subscript[-1:, :1:])
+        self.assertEqual((slice(-1, None, None), slice(-1, -1, -1)), subscript[-1:, -1:-1:-1])
+        self.assertEqual((slice(-1, None, None), slice(-1, -1, None)), subscript[-1:, -1:-1])
+        self.assertEqual((slice(-1, None, None), slice(-1, -1, None)), subscript[-1:, -1:-1:])
+        self.assertEqual((slice(-1, None, None), slice(-1, None, -1)), subscript[-1:, -1::-1])
+        self.assertEqual((slice(-1, None, None), slice(-1, None, None)), subscript[-1:, -1:])
+        self.assertEqual((slice(-1, None, None), slice(-1, None, None)), subscript[-1:, -1::])
+        self.assertEqual((slice(-1, None, None), slice(None, -1, -1)), subscript[-1:, :-1:-1])
+        self.assertEqual((slice(-1, None, None), slice(None, -1, None)), subscript[-1:, :-1])
+        self.assertEqual((slice(-1, None, None), slice(None, -1, None)), subscript[-1:, :-1:])
+        self.assertEqual((slice(-1, None, None), slice(1, -1, -1)), subscript[-1:, 1:-1:-1])
+        self.assertEqual((slice(-1, None, None), slice(-1, 1, -1)), subscript[-1:, -1:1:-1])
+        self.assertEqual((slice(-1, None, None), slice(-1, -1, 1)), subscript[-1:, -1:-1:1])
+        self.assertEqual((slice(-1, None, None), slice(1, 1, -1)), subscript[-1:, 1:1:-1])
+        self.assertEqual((slice(-1, None, None), slice(1, -1, 1)), subscript[-1:, 1:-1:1])
+        self.assertEqual((slice(-1, None, None), slice(-1, 1, 1)), subscript[-1:, -1:1:1])
+        self.assertEqual((slice(-1, None, None), slice(1, -1, None)), subscript[-1:, 1:-1])
+        self.assertEqual((slice(-1, None, None), slice(1, -1, None)), subscript[-1:, 1:-1:])
+        self.assertEqual((slice(-1, None, None), slice(-1, 1, None)), subscript[-1:, -1:1])
+        self.assertEqual((slice(-1, None, None), slice(-1, 1, None)), subscript[-1:, -1:1:])
+        self.assertEqual((slice(-1, None, None), slice(1, None, -1)), subscript[-1:, 1::-1])
+        self.assertEqual((slice(-1, None, None), slice(-1, None, 1)), subscript[-1:, -1::1])
+        self.assertEqual((slice(-1, None, None), slice(None, 1, -1)), subscript[-1:, :1:-1])
+        self.assertEqual((slice(-1, None, None), slice(None, -1, 1)), subscript[-1:, :-1:1])
+        self.assertEqual((slice(None, -1, -1), None), subscript[:-1:-1, None])
+        self.assertEqual((slice(None, -1, -1), ''), subscript[:-1:-1 ,''])
+        self.assertEqual((slice(None, -1, -1), 5), subscript[:-1:-1, 5])
+        self.assertEqual((slice(None, -1, -1), slice(None, None, None)), subscript[:-1:-1, :])
+        self.assertEqual((slice(None, -1, -1), slice(1, 1, 1)), subscript[:-1:-1, 1:1:1])
+        self.assertEqual((slice(None, -1, -1), slice(1, 1, None)), subscript[:-1:-1, 1:1])
+        self.assertEqual((slice(None, -1, -1), slice(1, 1, None)), subscript[:-1:-1, 1:1:])
+        self.assertEqual((slice(None, -1, -1), slice(1, None, 1)), subscript[:-1:-1, 1::1])
+        self.assertEqual((slice(None, -1, -1), slice(1, None, None)), subscript[:-1:-1, 1:])
+        self.assertEqual((slice(None, -1, -1), slice(1, None, None)), subscript[:-1:-1, 1::])
+        self.assertEqual((slice(None, -1, -1), slice(None, 1, 1)), subscript[:-1:-1, :1:1])
+        self.assertEqual((slice(None, -1, -1), slice(None, 1, None)), subscript[:-1:-1, :1])
+        self.assertEqual((slice(None, -1, -1), slice(None, 1, None)), subscript[:-1:-1, :1:])
+        self.assertEqual((slice(None, -1, -1), slice(-1, -1, -1)), subscript[:-1:-1, -1:-1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, -1, None)), subscript[:-1:-1, -1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, -1, None)), subscript[:-1:-1, -1:-1:])
+        self.assertEqual((slice(None, -1, -1), slice(-1, None, -1)), subscript[:-1:-1, -1::-1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, None, None)), subscript[:-1:-1, -1:])
+        self.assertEqual((slice(None, -1, -1), slice(-1, None, None)), subscript[:-1:-1, -1::])
+        self.assertEqual((slice(None, -1, -1), slice(None, -1, -1)), subscript[:-1:-1, :-1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(None, -1, None)), subscript[:-1:-1, :-1])
+        self.assertEqual((slice(None, -1, -1), slice(None, -1, None)), subscript[:-1:-1, :-1:])
+        self.assertEqual((slice(None, -1, -1), slice(1, -1, -1)), subscript[:-1:-1, 1:-1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, 1, -1)), subscript[:-1:-1, -1:1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, -1, 1)), subscript[:-1:-1, -1:-1:1])
+        self.assertEqual((slice(None, -1, -1), slice(1, 1, -1)), subscript[:-1:-1, 1:1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(1, -1, 1)), subscript[:-1:-1, 1:-1:1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, 1, 1)), subscript[:-1:-1, -1:1:1])
+        self.assertEqual((slice(None, -1, -1), slice(1, -1, None)), subscript[:-1:-1, 1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(1, -1, None)), subscript[:-1:-1, 1:-1:])
+        self.assertEqual((slice(None, -1, -1), slice(-1, 1, None)), subscript[:-1:-1, -1:1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, 1, None)), subscript[:-1:-1, -1:1:])
+        self.assertEqual((slice(None, -1, -1), slice(1, None, -1)), subscript[:-1:-1, 1::-1])
+        self.assertEqual((slice(None, -1, -1), slice(-1, None, 1)), subscript[:-1:-1, -1::1])
+        self.assertEqual((slice(None, -1, -1), slice(None, 1, -1)), subscript[:-1:-1, :1:-1])
+        self.assertEqual((slice(None, -1, -1), slice(None, -1, 1)), subscript[:-1:-1, :-1:1])
+        self.assertEqual((slice(None, -1, None), None), subscript[:-1, None])
+        self.assertEqual((slice(None, -1, None), ''), subscript[:-1 ,''])
+        self.assertEqual((slice(None, -1, None), 5), subscript[:-1, 5])
+        self.assertEqual((slice(None, -1, None), slice(None, None, None)), subscript[:-1, :])
+        self.assertEqual((slice(None, -1, None), slice(1, 1, 1)), subscript[:-1, 1:1:1])
+        self.assertEqual((slice(None, -1, None), slice(1, 1, None)), subscript[:-1, 1:1])
+        self.assertEqual((slice(None, -1, None), slice(1, 1, None)), subscript[:-1, 1:1:])
+        self.assertEqual((slice(None, -1, None), slice(1, None, 1)), subscript[:-1, 1::1])
+        self.assertEqual((slice(None, -1, None), slice(1, None, None)), subscript[:-1, 1:])
+        self.assertEqual((slice(None, -1, None), slice(1, None, None)), subscript[:-1, 1::])
+        self.assertEqual((slice(None, -1, None), slice(None, 1, 1)), subscript[:-1, :1:1])
+        self.assertEqual((slice(None, -1, None), slice(None, 1, None)), subscript[:-1, :1])
+        self.assertEqual((slice(None, -1, None), slice(None, 1, None)), subscript[:-1, :1:])
+        self.assertEqual((slice(None, -1, None), slice(-1, -1, -1)), subscript[:-1, -1:-1:-1])
+        self.assertEqual((slice(None, -1, None), slice(-1, -1, None)), subscript[:-1, -1:-1])
+        self.assertEqual((slice(None, -1, None), slice(-1, -1, None)), subscript[:-1, -1:-1:])
+        self.assertEqual((slice(None, -1, None), slice(-1, None, -1)), subscript[:-1, -1::-1])
+        self.assertEqual((slice(None, -1, None), slice(-1, None, None)), subscript[:-1, -1:])
+        self.assertEqual((slice(None, -1, None), slice(-1, None, None)), subscript[:-1, -1::])
+        self.assertEqual((slice(None, -1, None), slice(None, -1, -1)), subscript[:-1, :-1:-1])
+        self.assertEqual((slice(None, -1, None), slice(None, -1, None)), subscript[:-1, :-1])
+        self.assertEqual((slice(None, -1, None), slice(None, -1, None)), subscript[:-1, :-1:])
+        self.assertEqual((slice(None, -1, None), slice(1, -1, -1)), subscript[:-1, 1:-1:-1])
+        self.assertEqual((slice(None, -1, None), slice(-1, 1, -1)), subscript[:-1, -1:1:-1])
+        self.assertEqual((slice(None, -1, None), slice(-1, -1, 1)), subscript[:-1, -1:-1:1])
+        self.assertEqual((slice(None, -1, None), slice(1, 1, -1)), subscript[:-1, 1:1:-1])
+        self.assertEqual((slice(None, -1, None), slice(1, -1, 1)), subscript[:-1, 1:-1:1])
+        self.assertEqual((slice(None, -1, None), slice(-1, 1, 1)), subscript[:-1, -1:1:1])
+        self.assertEqual((slice(None, -1, None), slice(1, -1, None)), subscript[:-1, 1:-1])
+        self.assertEqual((slice(None, -1, None), slice(1, -1, None)), subscript[:-1, 1:-1:])
+        self.assertEqual((slice(None, -1, None), slice(-1, 1, None)), subscript[:-1, -1:1])
+        self.assertEqual((slice(None, -1, None), slice(-1, 1, None)), subscript[:-1, -1:1:])
+        self.assertEqual((slice(None, -1, None), slice(1, None, -1)), subscript[:-1, 1::-1])
+        self.assertEqual((slice(None, -1, None), slice(-1, None, 1)), subscript[:-1, -1::1])
+        self.assertEqual((slice(None, -1, None), slice(None, 1, -1)), subscript[:-1, :1:-1])
+        self.assertEqual((slice(None, -1, None), slice(None, -1, 1)), subscript[:-1, :-1:1])
+        self.assertEqual((slice(1, -1, -1), None), subscript[1:-1:-1, None])
+        self.assertEqual((slice(1, -1, -1), ''), subscript[1:-1:-1 ,''])
+        self.assertEqual((slice(1, -1, -1), 5), subscript[1:-1:-1, 5])
+        self.assertEqual((slice(1, -1, -1), slice(None, None, None)), subscript[1:-1:-1, :])
+        self.assertEqual((slice(1, -1, -1), slice(1, 1, 1)), subscript[1:-1:-1, 1:1:1])
+        self.assertEqual((slice(1, -1, -1), slice(1, 1, None)), subscript[1:-1:-1, 1:1])
+        self.assertEqual((slice(1, -1, -1), slice(1, 1, None)), subscript[1:-1:-1, 1:1:])
+        self.assertEqual((slice(1, -1, -1), slice(1, None, 1)), subscript[1:-1:-1, 1::1])
+        self.assertEqual((slice(1, -1, -1), slice(1, None, None)), subscript[1:-1:-1, 1:])
+        self.assertEqual((slice(1, -1, -1), slice(1, None, None)), subscript[1:-1:-1, 1::])
+        self.assertEqual((slice(1, -1, -1), slice(None, 1, 1)), subscript[1:-1:-1, :1:1])
+        self.assertEqual((slice(1, -1, -1), slice(None, 1, None)), subscript[1:-1:-1, :1])
+        self.assertEqual((slice(1, -1, -1), slice(None, 1, None)), subscript[1:-1:-1, :1:])
+        self.assertEqual((slice(1, -1, -1), slice(-1, -1, -1)), subscript[1:-1:-1, -1:-1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, -1, None)), subscript[1:-1:-1, -1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, -1, None)), subscript[1:-1:-1, -1:-1:])
+        self.assertEqual((slice(1, -1, -1), slice(-1, None, -1)), subscript[1:-1:-1, -1::-1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, None, None)), subscript[1:-1:-1, -1:])
+        self.assertEqual((slice(1, -1, -1), slice(-1, None, None)), subscript[1:-1:-1, -1::])
+        self.assertEqual((slice(1, -1, -1), slice(None, -1, -1)), subscript[1:-1:-1, :-1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(None, -1, None)), subscript[1:-1:-1, :-1])
+        self.assertEqual((slice(1, -1, -1), slice(None, -1, None)), subscript[1:-1:-1, :-1:])
+        self.assertEqual((slice(1, -1, -1), slice(1, -1, -1)), subscript[1:-1:-1, 1:-1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, 1, -1)), subscript[1:-1:-1, -1:1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, -1, 1)), subscript[1:-1:-1, -1:-1:1])
+        self.assertEqual((slice(1, -1, -1), slice(1, 1, -1)), subscript[1:-1:-1, 1:1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(1, -1, 1)), subscript[1:-1:-1, 1:-1:1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, 1, 1)), subscript[1:-1:-1, -1:1:1])
+        self.assertEqual((slice(1, -1, -1), slice(1, -1, None)), subscript[1:-1:-1, 1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(1, -1, None)), subscript[1:-1:-1, 1:-1:])
+        self.assertEqual((slice(1, -1, -1), slice(-1, 1, None)), subscript[1:-1:-1, -1:1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, 1, None)), subscript[1:-1:-1, -1:1:])
+        self.assertEqual((slice(1, -1, -1), slice(1, None, -1)), subscript[1:-1:-1, 1::-1])
+        self.assertEqual((slice(1, -1, -1), slice(-1, None, 1)), subscript[1:-1:-1, -1::1])
+        self.assertEqual((slice(1, -1, -1), slice(None, 1, -1)), subscript[1:-1:-1, :1:-1])
+        self.assertEqual((slice(1, -1, -1), slice(None, -1, 1)), subscript[1:-1:-1, :-1:1])
+        self.assertEqual((slice(-1, 1, -1), None), subscript[-1:1:-1, None])
+        self.assertEqual((slice(-1, 1, -1), ''), subscript[-1:1:-1 ,''])
+        self.assertEqual((slice(-1, 1, -1), 5), subscript[-1:1:-1, 5])
+        self.assertEqual((slice(-1, 1, -1), slice(None, None, None)), subscript[-1:1:-1, :])
+        self.assertEqual((slice(-1, 1, -1), slice(1, 1, 1)), subscript[-1:1:-1, 1:1:1])
+        self.assertEqual((slice(-1, 1, -1), slice(1, 1, None)), subscript[-1:1:-1, 1:1])
+        self.assertEqual((slice(-1, 1, -1), slice(1, 1, None)), subscript[-1:1:-1, 1:1:])
+        self.assertEqual((slice(-1, 1, -1), slice(1, None, 1)), subscript[-1:1:-1, 1::1])
+        self.assertEqual((slice(-1, 1, -1), slice(1, None, None)), subscript[-1:1:-1, 1:])
+        self.assertEqual((slice(-1, 1, -1), slice(1, None, None)), subscript[-1:1:-1, 1::])
+        self.assertEqual((slice(-1, 1, -1), slice(None, 1, 1)), subscript[-1:1:-1, :1:1])
+        self.assertEqual((slice(-1, 1, -1), slice(None, 1, None)), subscript[-1:1:-1, :1])
+        self.assertEqual((slice(-1, 1, -1), slice(None, 1, None)), subscript[-1:1:-1, :1:])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, -1, -1)), subscript[-1:1:-1, -1:-1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, -1, None)), subscript[-1:1:-1, -1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, -1, None)), subscript[-1:1:-1, -1:-1:])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, None, -1)), subscript[-1:1:-1, -1::-1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, None, None)), subscript[-1:1:-1, -1:])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, None, None)), subscript[-1:1:-1, -1::])
+        self.assertEqual((slice(-1, 1, -1), slice(None, -1, -1)), subscript[-1:1:-1, :-1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(None, -1, None)), subscript[-1:1:-1, :-1])
+        self.assertEqual((slice(-1, 1, -1), slice(None, -1, None)), subscript[-1:1:-1, :-1:])
+        self.assertEqual((slice(-1, 1, -1), slice(1, -1, -1)), subscript[-1:1:-1, 1:-1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, 1, -1)), subscript[-1:1:-1, -1:1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, -1, 1)), subscript[-1:1:-1, -1:-1:1])
+        self.assertEqual((slice(-1, 1, -1), slice(1, 1, -1)), subscript[-1:1:-1, 1:1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(1, -1, 1)), subscript[-1:1:-1, 1:-1:1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, 1, 1)), subscript[-1:1:-1, -1:1:1])
+        self.assertEqual((slice(-1, 1, -1), slice(1, -1, None)), subscript[-1:1:-1, 1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(1, -1, None)), subscript[-1:1:-1, 1:-1:])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, 1, None)), subscript[-1:1:-1, -1:1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, 1, None)), subscript[-1:1:-1, -1:1:])
+        self.assertEqual((slice(-1, 1, -1), slice(1, None, -1)), subscript[-1:1:-1, 1::-1])
+        self.assertEqual((slice(-1, 1, -1), slice(-1, None, 1)), subscript[-1:1:-1, -1::1])
+        self.assertEqual((slice(-1, 1, -1), slice(None, 1, -1)), subscript[-1:1:-1, :1:-1])
+        self.assertEqual((slice(-1, 1, -1), slice(None, -1, 1)), subscript[-1:1:-1, :-1:1])
+        self.assertEqual((slice(-1, -1, 1), None), subscript[-1:-1:1, None])
+        self.assertEqual((slice(-1, -1, 1), ''), subscript[-1:-1:1 ,''])
+        self.assertEqual((slice(-1, -1, 1), 5), subscript[-1:-1:1, 5])
+        self.assertEqual((slice(-1, -1, 1), slice(None, None, None)), subscript[-1:-1:1, :])
+        self.assertEqual((slice(-1, -1, 1), slice(1, 1, 1)), subscript[-1:-1:1, 1:1:1])
+        self.assertEqual((slice(-1, -1, 1), slice(1, 1, None)), subscript[-1:-1:1, 1:1])
+        self.assertEqual((slice(-1, -1, 1), slice(1, 1, None)), subscript[-1:-1:1, 1:1:])
+        self.assertEqual((slice(-1, -1, 1), slice(1, None, 1)), subscript[-1:-1:1, 1::1])
+        self.assertEqual((slice(-1, -1, 1), slice(1, None, None)), subscript[-1:-1:1, 1:])
+        self.assertEqual((slice(-1, -1, 1), slice(1, None, None)), subscript[-1:-1:1, 1::])
+        self.assertEqual((slice(-1, -1, 1), slice(None, 1, 1)), subscript[-1:-1:1, :1:1])
+        self.assertEqual((slice(-1, -1, 1), slice(None, 1, None)), subscript[-1:-1:1, :1])
+        self.assertEqual((slice(-1, -1, 1), slice(None, 1, None)), subscript[-1:-1:1, :1:])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, -1, -1)), subscript[-1:-1:1, -1:-1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, -1, None)), subscript[-1:-1:1, -1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, -1, None)), subscript[-1:-1:1, -1:-1:])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, None, -1)), subscript[-1:-1:1, -1::-1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, None, None)), subscript[-1:-1:1, -1:])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, None, None)), subscript[-1:-1:1, -1::])
+        self.assertEqual((slice(-1, -1, 1), slice(None, -1, -1)), subscript[-1:-1:1, :-1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(None, -1, None)), subscript[-1:-1:1, :-1])
+        self.assertEqual((slice(-1, -1, 1), slice(None, -1, None)), subscript[-1:-1:1, :-1:])
+        self.assertEqual((slice(-1, -1, 1), slice(1, -1, -1)), subscript[-1:-1:1, 1:-1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, 1, -1)), subscript[-1:-1:1, -1:1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, -1, 1)), subscript[-1:-1:1, -1:-1:1])
+        self.assertEqual((slice(-1, -1, 1), slice(1, 1, -1)), subscript[-1:-1:1, 1:1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(1, -1, 1)), subscript[-1:-1:1, 1:-1:1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, 1, 1)), subscript[-1:-1:1, -1:1:1])
+        self.assertEqual((slice(-1, -1, 1), slice(1, -1, None)), subscript[-1:-1:1, 1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(1, -1, None)), subscript[-1:-1:1, 1:-1:])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, 1, None)), subscript[-1:-1:1, -1:1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, 1, None)), subscript[-1:-1:1, -1:1:])
+        self.assertEqual((slice(-1, -1, 1), slice(1, None, -1)), subscript[-1:-1:1, 1::-1])
+        self.assertEqual((slice(-1, -1, 1), slice(-1, None, 1)), subscript[-1:-1:1, -1::1])
+        self.assertEqual((slice(-1, -1, 1), slice(None, 1, -1)), subscript[-1:-1:1, :1:-1])
+        self.assertEqual((slice(-1, -1, 1), slice(None, -1, 1)), subscript[-1:-1:1, :-1:1])
+        self.assertEqual((slice(1, 1, -1), None), subscript[1:1:-1, None])
+        self.assertEqual((slice(1, 1, -1), ''), subscript[1:1:-1 ,''])
+        self.assertEqual((slice(1, 1, -1), 5), subscript[1:1:-1, 5])
+        self.assertEqual((slice(1, 1, -1), slice(None, None, None)), subscript[1:1:-1, :])
+        self.assertEqual((slice(1, 1, -1), slice(1, 1, 1)), subscript[1:1:-1, 1:1:1])
+        self.assertEqual((slice(1, 1, -1), slice(1, 1, None)), subscript[1:1:-1, 1:1])
+        self.assertEqual((slice(1, 1, -1), slice(1, 1, None)), subscript[1:1:-1, 1:1:])
+        self.assertEqual((slice(1, 1, -1), slice(1, None, 1)), subscript[1:1:-1, 1::1])
+        self.assertEqual((slice(1, 1, -1), slice(1, None, None)), subscript[1:1:-1, 1:])
+        self.assertEqual((slice(1, 1, -1), slice(1, None, None)), subscript[1:1:-1, 1::])
+        self.assertEqual((slice(1, 1, -1), slice(None, 1, 1)), subscript[1:1:-1, :1:1])
+        self.assertEqual((slice(1, 1, -1), slice(None, 1, None)), subscript[1:1:-1, :1])
+        self.assertEqual((slice(1, 1, -1), slice(None, 1, None)), subscript[1:1:-1, :1:])
+        self.assertEqual((slice(1, 1, -1), slice(-1, -1, -1)), subscript[1:1:-1, -1:-1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, -1, None)), subscript[1:1:-1, -1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, -1, None)), subscript[1:1:-1, -1:-1:])
+        self.assertEqual((slice(1, 1, -1), slice(-1, None, -1)), subscript[1:1:-1, -1::-1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, None, None)), subscript[1:1:-1, -1:])
+        self.assertEqual((slice(1, 1, -1), slice(-1, None, None)), subscript[1:1:-1, -1::])
+        self.assertEqual((slice(1, 1, -1), slice(None, -1, -1)), subscript[1:1:-1, :-1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(None, -1, None)), subscript[1:1:-1, :-1])
+        self.assertEqual((slice(1, 1, -1), slice(None, -1, None)), subscript[1:1:-1, :-1:])
+        self.assertEqual((slice(1, 1, -1), slice(1, -1, -1)), subscript[1:1:-1, 1:-1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, 1, -1)), subscript[1:1:-1, -1:1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, -1, 1)), subscript[1:1:-1, -1:-1:1])
+        self.assertEqual((slice(1, 1, -1), slice(1, 1, -1)), subscript[1:1:-1, 1:1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(1, -1, 1)), subscript[1:1:-1, 1:-1:1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, 1, 1)), subscript[1:1:-1, -1:1:1])
+        self.assertEqual((slice(1, 1, -1), slice(1, -1, None)), subscript[1:1:-1, 1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(1, -1, None)), subscript[1:1:-1, 1:-1:])
+        self.assertEqual((slice(1, 1, -1), slice(-1, 1, None)), subscript[1:1:-1, -1:1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, 1, None)), subscript[1:1:-1, -1:1:])
+        self.assertEqual((slice(1, 1, -1), slice(1, None, -1)), subscript[1:1:-1, 1::-1])
+        self.assertEqual((slice(1, 1, -1), slice(-1, None, 1)), subscript[1:1:-1, -1::1])
+        self.assertEqual((slice(1, 1, -1), slice(None, 1, -1)), subscript[1:1:-1, :1:-1])
+        self.assertEqual((slice(1, 1, -1), slice(None, -1, 1)), subscript[1:1:-1, :-1:1])
+        self.assertEqual((slice(1, -1, 1), None), subscript[1:-1:1, None])
+        self.assertEqual((slice(1, -1, 1), ''), subscript[1:-1:1 ,''])
+        self.assertEqual((slice(1, -1, 1), 5), subscript[1:-1:1, 5])
+        self.assertEqual((slice(1, -1, 1), slice(None, None, None)), subscript[1:-1:1, :])
+        self.assertEqual((slice(1, -1, 1), slice(1, 1, 1)), subscript[1:-1:1, 1:1:1])
+        self.assertEqual((slice(1, -1, 1), slice(1, 1, None)), subscript[1:-1:1, 1:1])
+        self.assertEqual((slice(1, -1, 1), slice(1, 1, None)), subscript[1:-1:1, 1:1:])
+        self.assertEqual((slice(1, -1, 1), slice(1, None, 1)), subscript[1:-1:1, 1::1])
+        self.assertEqual((slice(1, -1, 1), slice(1, None, None)), subscript[1:-1:1, 1:])
+        self.assertEqual((slice(1, -1, 1), slice(1, None, None)), subscript[1:-1:1, 1::])
+        self.assertEqual((slice(1, -1, 1), slice(None, 1, 1)), subscript[1:-1:1, :1:1])
+        self.assertEqual((slice(1, -1, 1), slice(None, 1, None)), subscript[1:-1:1, :1])
+        self.assertEqual((slice(1, -1, 1), slice(None, 1, None)), subscript[1:-1:1, :1:])
+        self.assertEqual((slice(1, -1, 1), slice(-1, -1, -1)), subscript[1:-1:1, -1:-1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, -1, None)), subscript[1:-1:1, -1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, -1, None)), subscript[1:-1:1, -1:-1:])
+        self.assertEqual((slice(1, -1, 1), slice(-1, None, -1)), subscript[1:-1:1, -1::-1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, None, None)), subscript[1:-1:1, -1:])
+        self.assertEqual((slice(1, -1, 1), slice(-1, None, None)), subscript[1:-1:1, -1::])
+        self.assertEqual((slice(1, -1, 1), slice(None, -1, -1)), subscript[1:-1:1, :-1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(None, -1, None)), subscript[1:-1:1, :-1])
+        self.assertEqual((slice(1, -1, 1), slice(None, -1, None)), subscript[1:-1:1, :-1:])
+        self.assertEqual((slice(1, -1, 1), slice(1, -1, -1)), subscript[1:-1:1, 1:-1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, 1, -1)), subscript[1:-1:1, -1:1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, -1, 1)), subscript[1:-1:1, -1:-1:1])
+        self.assertEqual((slice(1, -1, 1), slice(1, 1, -1)), subscript[1:-1:1, 1:1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(1, -1, 1)), subscript[1:-1:1, 1:-1:1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, 1, 1)), subscript[1:-1:1, -1:1:1])
+        self.assertEqual((slice(1, -1, 1), slice(1, -1, None)), subscript[1:-1:1, 1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(1, -1, None)), subscript[1:-1:1, 1:-1:])
+        self.assertEqual((slice(1, -1, 1), slice(-1, 1, None)), subscript[1:-1:1, -1:1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, 1, None)), subscript[1:-1:1, -1:1:])
+        self.assertEqual((slice(1, -1, 1), slice(1, None, -1)), subscript[1:-1:1, 1::-1])
+        self.assertEqual((slice(1, -1, 1), slice(-1, None, 1)), subscript[1:-1:1, -1::1])
+        self.assertEqual((slice(1, -1, 1), slice(None, 1, -1)), subscript[1:-1:1, :1:-1])
+        self.assertEqual((slice(1, -1, 1), slice(None, -1, 1)), subscript[1:-1:1, :-1:1])
+        self.assertEqual((slice(-1, 1, 1), None), subscript[-1:1:1, None])
+        self.assertEqual((slice(-1, 1, 1), ''), subscript[-1:1:1 ,''])
+        self.assertEqual((slice(-1, 1, 1), 5), subscript[-1:1:1, 5])
+        self.assertEqual((slice(-1, 1, 1), slice(None, None, None)), subscript[-1:1:1, :])
+        self.assertEqual((slice(-1, 1, 1), slice(1, 1, 1)), subscript[-1:1:1, 1:1:1])
+        self.assertEqual((slice(-1, 1, 1), slice(1, 1, None)), subscript[-1:1:1, 1:1])
+        self.assertEqual((slice(-1, 1, 1), slice(1, 1, None)), subscript[-1:1:1, 1:1:])
+        self.assertEqual((slice(-1, 1, 1), slice(1, None, 1)), subscript[-1:1:1, 1::1])
+        self.assertEqual((slice(-1, 1, 1), slice(1, None, None)), subscript[-1:1:1, 1:])
+        self.assertEqual((slice(-1, 1, 1), slice(1, None, None)), subscript[-1:1:1, 1::])
+        self.assertEqual((slice(-1, 1, 1), slice(None, 1, 1)), subscript[-1:1:1, :1:1])
+        self.assertEqual((slice(-1, 1, 1), slice(None, 1, None)), subscript[-1:1:1, :1])
+        self.assertEqual((slice(-1, 1, 1), slice(None, 1, None)), subscript[-1:1:1, :1:])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, -1, -1)), subscript[-1:1:1, -1:-1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, -1, None)), subscript[-1:1:1, -1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, -1, None)), subscript[-1:1:1, -1:-1:])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, None, -1)), subscript[-1:1:1, -1::-1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, None, None)), subscript[-1:1:1, -1:])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, None, None)), subscript[-1:1:1, -1::])
+        self.assertEqual((slice(-1, 1, 1), slice(None, -1, -1)), subscript[-1:1:1, :-1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(None, -1, None)), subscript[-1:1:1, :-1])
+        self.assertEqual((slice(-1, 1, 1), slice(None, -1, None)), subscript[-1:1:1, :-1:])
+        self.assertEqual((slice(-1, 1, 1), slice(1, -1, -1)), subscript[-1:1:1, 1:-1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, 1, -1)), subscript[-1:1:1, -1:1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, -1, 1)), subscript[-1:1:1, -1:-1:1])
+        self.assertEqual((slice(-1, 1, 1), slice(1, 1, -1)), subscript[-1:1:1, 1:1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(1, -1, 1)), subscript[-1:1:1, 1:-1:1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, 1, 1)), subscript[-1:1:1, -1:1:1])
+        self.assertEqual((slice(-1, 1, 1), slice(1, -1, None)), subscript[-1:1:1, 1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(1, -1, None)), subscript[-1:1:1, 1:-1:])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, 1, None)), subscript[-1:1:1, -1:1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, 1, None)), subscript[-1:1:1, -1:1:])
+        self.assertEqual((slice(-1, 1, 1), slice(1, None, -1)), subscript[-1:1:1, 1::-1])
+        self.assertEqual((slice(-1, 1, 1), slice(-1, None, 1)), subscript[-1:1:1, -1::1])
+        self.assertEqual((slice(-1, 1, 1), slice(None, 1, -1)), subscript[-1:1:1, :1:-1])
+        self.assertEqual((slice(-1, 1, 1), slice(None, -1, 1)), subscript[-1:1:1, :-1:1])
+        self.assertEqual((slice(1, -1, None), None), subscript[1:-1, None])
+        self.assertEqual((slice(1, -1, None), ''), subscript[1:-1 ,''])
+        self.assertEqual((slice(1, -1, None), 5), subscript[1:-1, 5])
+        self.assertEqual((slice(1, -1, None), slice(None, None, None)), subscript[1:-1, :])
+        self.assertEqual((slice(1, -1, None), slice(1, 1, 1)), subscript[1:-1, 1:1:1])
+        self.assertEqual((slice(1, -1, None), slice(1, 1, None)), subscript[1:-1, 1:1])
+        self.assertEqual((slice(1, -1, None), slice(1, 1, None)), subscript[1:-1, 1:1:])
+        self.assertEqual((slice(1, -1, None), slice(1, None, 1)), subscript[1:-1, 1::1])
+        self.assertEqual((slice(1, -1, None), slice(1, None, None)), subscript[1:-1, 1:])
+        self.assertEqual((slice(1, -1, None), slice(1, None, None)), subscript[1:-1, 1::])
+        self.assertEqual((slice(1, -1, None), slice(None, 1, 1)), subscript[1:-1, :1:1])
+        self.assertEqual((slice(1, -1, None), slice(None, 1, None)), subscript[1:-1, :1])
+        self.assertEqual((slice(1, -1, None), slice(None, 1, None)), subscript[1:-1, :1:])
+        self.assertEqual((slice(1, -1, None), slice(-1, -1, -1)), subscript[1:-1, -1:-1:-1])
+        self.assertEqual((slice(1, -1, None), slice(-1, -1, None)), subscript[1:-1, -1:-1])
+        self.assertEqual((slice(1, -1, None), slice(-1, -1, None)), subscript[1:-1, -1:-1:])
+        self.assertEqual((slice(1, -1, None), slice(-1, None, -1)), subscript[1:-1, -1::-1])
+        self.assertEqual((slice(1, -1, None), slice(-1, None, None)), subscript[1:-1, -1:])
+        self.assertEqual((slice(1, -1, None), slice(-1, None, None)), subscript[1:-1, -1::])
+        self.assertEqual((slice(1, -1, None), slice(None, -1, -1)), subscript[1:-1, :-1:-1])
+        self.assertEqual((slice(1, -1, None), slice(None, -1, None)), subscript[1:-1, :-1])
+        self.assertEqual((slice(1, -1, None), slice(None, -1, None)), subscript[1:-1, :-1:])
+        self.assertEqual((slice(1, -1, None), slice(1, -1, -1)), subscript[1:-1, 1:-1:-1])
+        self.assertEqual((slice(1, -1, None), slice(-1, 1, -1)), subscript[1:-1, -1:1:-1])
+        self.assertEqual((slice(1, -1, None), slice(-1, -1, 1)), subscript[1:-1, -1:-1:1])
+        self.assertEqual((slice(1, -1, None), slice(1, 1, -1)), subscript[1:-1, 1:1:-1])
+        self.assertEqual((slice(1, -1, None), slice(1, -1, 1)), subscript[1:-1, 1:-1:1])
+        self.assertEqual((slice(1, -1, None), slice(-1, 1, 1)), subscript[1:-1, -1:1:1])
+        self.assertEqual((slice(1, -1, None), slice(1, -1, None)), subscript[1:-1, 1:-1])
+        self.assertEqual((slice(1, -1, None), slice(1, -1, None)), subscript[1:-1, 1:-1:])
+        self.assertEqual((slice(1, -1, None), slice(-1, 1, None)), subscript[1:-1, -1:1])
+        self.assertEqual((slice(1, -1, None), slice(-1, 1, None)), subscript[1:-1, -1:1:])
+        self.assertEqual((slice(1, -1, None), slice(1, None, -1)), subscript[1:-1, 1::-1])
+        self.assertEqual((slice(1, -1, None), slice(-1, None, 1)), subscript[1:-1, -1::1])
+        self.assertEqual((slice(1, -1, None), slice(None, 1, -1)), subscript[1:-1, :1:-1])
+        self.assertEqual((slice(1, -1, None), slice(None, -1, 1)), subscript[1:-1, :-1:1])
+        self.assertEqual((slice(-1, 1, None), None), subscript[-1:1, None])
+        self.assertEqual((slice(-1, 1, None), ''), subscript[-1:1 ,''])
+        self.assertEqual((slice(-1, 1, None), 5), subscript[-1:1, 5])
+        self.assertEqual((slice(-1, 1, None), slice(None, None, None)), subscript[-1:1, :])
+        self.assertEqual((slice(-1, 1, None), slice(1, 1, 1)), subscript[-1:1, 1:1:1])
+        self.assertEqual((slice(-1, 1, None), slice(1, 1, None)), subscript[-1:1, 1:1])
+        self.assertEqual((slice(-1, 1, None), slice(1, 1, None)), subscript[-1:1, 1:1:])
+        self.assertEqual((slice(-1, 1, None), slice(1, None, 1)), subscript[-1:1, 1::1])
+        self.assertEqual((slice(-1, 1, None), slice(1, None, None)), subscript[-1:1, 1:])
+        self.assertEqual((slice(-1, 1, None), slice(1, None, None)), subscript[-1:1, 1::])
+        self.assertEqual((slice(-1, 1, None), slice(None, 1, 1)), subscript[-1:1, :1:1])
+        self.assertEqual((slice(-1, 1, None), slice(None, 1, None)), subscript[-1:1, :1])
+        self.assertEqual((slice(-1, 1, None), slice(None, 1, None)), subscript[-1:1, :1:])
+        self.assertEqual((slice(-1, 1, None), slice(-1, -1, -1)), subscript[-1:1, -1:-1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, -1, None)), subscript[-1:1, -1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, -1, None)), subscript[-1:1, -1:-1:])
+        self.assertEqual((slice(-1, 1, None), slice(-1, None, -1)), subscript[-1:1, -1::-1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, None, None)), subscript[-1:1, -1:])
+        self.assertEqual((slice(-1, 1, None), slice(-1, None, None)), subscript[-1:1, -1::])
+        self.assertEqual((slice(-1, 1, None), slice(None, -1, -1)), subscript[-1:1, :-1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(None, -1, None)), subscript[-1:1, :-1])
+        self.assertEqual((slice(-1, 1, None), slice(None, -1, None)), subscript[-1:1, :-1:])
+        self.assertEqual((slice(-1, 1, None), slice(1, -1, -1)), subscript[-1:1, 1:-1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, 1, -1)), subscript[-1:1, -1:1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, -1, 1)), subscript[-1:1, -1:-1:1])
+        self.assertEqual((slice(-1, 1, None), slice(1, 1, -1)), subscript[-1:1, 1:1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(1, -1, 1)), subscript[-1:1, 1:-1:1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, 1, 1)), subscript[-1:1, -1:1:1])
+        self.assertEqual((slice(-1, 1, None), slice(1, -1, None)), subscript[-1:1, 1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(1, -1, None)), subscript[-1:1, 1:-1:])
+        self.assertEqual((slice(-1, 1, None), slice(-1, 1, None)), subscript[-1:1, -1:1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, 1, None)), subscript[-1:1, -1:1:])
+        self.assertEqual((slice(-1, 1, None), slice(1, None, -1)), subscript[-1:1, 1::-1])
+        self.assertEqual((slice(-1, 1, None), slice(-1, None, 1)), subscript[-1:1, -1::1])
+        self.assertEqual((slice(-1, 1, None), slice(None, 1, -1)), subscript[-1:1, :1:-1])
+        self.assertEqual((slice(-1, 1, None), slice(None, -1, 1)), subscript[-1:1, :-1:1])
+        self.assertEqual((slice(1, None, -1), None), subscript[1::-1, None])
+        self.assertEqual((slice(1, None, -1), ''), subscript[1::-1 ,''])
+        self.assertEqual((slice(1, None, -1), 5), subscript[1::-1, 5])
+        self.assertEqual((slice(1, None, -1), slice(None, None, None)), subscript[1::-1, :])
+        self.assertEqual((slice(1, None, -1), slice(1, 1, 1)), subscript[1::-1, 1:1:1])
+        self.assertEqual((slice(1, None, -1), slice(1, 1, None)), subscript[1::-1, 1:1])
+        self.assertEqual((slice(1, None, -1), slice(1, 1, None)), subscript[1::-1, 1:1:])
+        self.assertEqual((slice(1, None, -1), slice(1, None, 1)), subscript[1::-1, 1::1])
+        self.assertEqual((slice(1, None, -1), slice(1, None, None)), subscript[1::-1, 1:])
+        self.assertEqual((slice(1, None, -1), slice(1, None, None)), subscript[1::-1, 1::])
+        self.assertEqual((slice(1, None, -1), slice(None, 1, 1)), subscript[1::-1, :1:1])
+        self.assertEqual((slice(1, None, -1), slice(None, 1, None)), subscript[1::-1, :1])
+        self.assertEqual((slice(1, None, -1), slice(None, 1, None)), subscript[1::-1, :1:])
+        self.assertEqual((slice(1, None, -1), slice(-1, -1, -1)), subscript[1::-1, -1:-1:-1])
+        self.assertEqual((slice(1, None, -1), slice(-1, -1, None)), subscript[1::-1, -1:-1])
+        self.assertEqual((slice(1, None, -1), slice(-1, -1, None)), subscript[1::-1, -1:-1:])
+        self.assertEqual((slice(1, None, -1), slice(-1, None, -1)), subscript[1::-1, -1::-1])
+        self.assertEqual((slice(1, None, -1), slice(-1, None, None)), subscript[1::-1, -1:])
+        self.assertEqual((slice(1, None, -1), slice(-1, None, None)), subscript[1::-1, -1::])
+        self.assertEqual((slice(1, None, -1), slice(None, -1, -1)), subscript[1::-1, :-1:-1])
+        self.assertEqual((slice(1, None, -1), slice(None, -1, None)), subscript[1::-1, :-1])
+        self.assertEqual((slice(1, None, -1), slice(None, -1, None)), subscript[1::-1, :-1:])
+        self.assertEqual((slice(1, None, -1), slice(1, -1, -1)), subscript[1::-1, 1:-1:-1])
+        self.assertEqual((slice(1, None, -1), slice(-1, 1, -1)), subscript[1::-1, -1:1:-1])
+        self.assertEqual((slice(1, None, -1), slice(-1, -1, 1)), subscript[1::-1, -1:-1:1])
+        self.assertEqual((slice(1, None, -1), slice(1, 1, -1)), subscript[1::-1, 1:1:-1])
+        self.assertEqual((slice(1, None, -1), slice(1, -1, 1)), subscript[1::-1, 1:-1:1])
+        self.assertEqual((slice(1, None, -1), slice(-1, 1, 1)), subscript[1::-1, -1:1:1])
+        self.assertEqual((slice(1, None, -1), slice(1, -1, None)), subscript[1::-1, 1:-1])
+        self.assertEqual((slice(1, None, -1), slice(1, -1, None)), subscript[1::-1, 1:-1:])
+        self.assertEqual((slice(1, None, -1), slice(-1, 1, None)), subscript[1::-1, -1:1])
+        self.assertEqual((slice(1, None, -1), slice(-1, 1, None)), subscript[1::-1, -1:1:])
+        self.assertEqual((slice(1, None, -1), slice(1, None, -1)), subscript[1::-1, 1::-1])
+        self.assertEqual((slice(1, None, -1), slice(-1, None, 1)), subscript[1::-1, -1::1])
+        self.assertEqual((slice(1, None, -1), slice(None, 1, -1)), subscript[1::-1, :1:-1])
+        self.assertEqual((slice(1, None, -1), slice(None, -1, 1)), subscript[1::-1, :-1:1])
+        self.assertEqual((slice(-1, None, 1), None), subscript[-1::1, None])
+        self.assertEqual((slice(-1, None, 1), ''), subscript[-1::1 ,''])
+        self.assertEqual((slice(-1, None, 1), 5), subscript[-1::1, 5])
+        self.assertEqual((slice(-1, None, 1), slice(None, None, None)), subscript[-1::1, :])
+        self.assertEqual((slice(-1, None, 1), slice(1, 1, 1)), subscript[-1::1, 1:1:1])
+        self.assertEqual((slice(-1, None, 1), slice(1, 1, None)), subscript[-1::1, 1:1])
+        self.assertEqual((slice(-1, None, 1), slice(1, 1, None)), subscript[-1::1, 1:1:])
+        self.assertEqual((slice(-1, None, 1), slice(1, None, 1)), subscript[-1::1, 1::1])
+        self.assertEqual((slice(-1, None, 1), slice(1, None, None)), subscript[-1::1, 1:])
+        self.assertEqual((slice(-1, None, 1), slice(1, None, None)), subscript[-1::1, 1::])
+        self.assertEqual((slice(-1, None, 1), slice(None, 1, 1)), subscript[-1::1, :1:1])
+        self.assertEqual((slice(-1, None, 1), slice(None, 1, None)), subscript[-1::1, :1])
+        self.assertEqual((slice(-1, None, 1), slice(None, 1, None)), subscript[-1::1, :1:])
+        self.assertEqual((slice(-1, None, 1), slice(-1, -1, -1)), subscript[-1::1, -1:-1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, -1, None)), subscript[-1::1, -1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, -1, None)), subscript[-1::1, -1:-1:])
+        self.assertEqual((slice(-1, None, 1), slice(-1, None, -1)), subscript[-1::1, -1::-1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, None, None)), subscript[-1::1, -1:])
+        self.assertEqual((slice(-1, None, 1), slice(-1, None, None)), subscript[-1::1, -1::])
+        self.assertEqual((slice(-1, None, 1), slice(None, -1, -1)), subscript[-1::1, :-1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(None, -1, None)), subscript[-1::1, :-1])
+        self.assertEqual((slice(-1, None, 1), slice(None, -1, None)), subscript[-1::1, :-1:])
+        self.assertEqual((slice(-1, None, 1), slice(1, -1, -1)), subscript[-1::1, 1:-1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, 1, -1)), subscript[-1::1, -1:1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, -1, 1)), subscript[-1::1, -1:-1:1])
+        self.assertEqual((slice(-1, None, 1), slice(1, 1, -1)), subscript[-1::1, 1:1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(1, -1, 1)), subscript[-1::1, 1:-1:1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, 1, 1)), subscript[-1::1, -1:1:1])
+        self.assertEqual((slice(-1, None, 1), slice(1, -1, None)), subscript[-1::1, 1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(1, -1, None)), subscript[-1::1, 1:-1:])
+        self.assertEqual((slice(-1, None, 1), slice(-1, 1, None)), subscript[-1::1, -1:1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, 1, None)), subscript[-1::1, -1:1:])
+        self.assertEqual((slice(-1, None, 1), slice(1, None, -1)), subscript[-1::1, 1::-1])
+        self.assertEqual((slice(-1, None, 1), slice(-1, None, 1)), subscript[-1::1, -1::1])
+        self.assertEqual((slice(-1, None, 1), slice(None, 1, -1)), subscript[-1::1, :1:-1])
+        self.assertEqual((slice(-1, None, 1), slice(None, -1, 1)), subscript[-1::1, :-1:1])
+        self.assertEqual((slice(None, 1, -1), None), subscript[:1:-1, None])
+        self.assertEqual((slice(None, 1, -1), ''), subscript[:1:-1 ,''])
+        self.assertEqual((slice(None, 1, -1), 5), subscript[:1:-1, 5])
+        self.assertEqual((slice(None, 1, -1), slice(None, None, None)), subscript[:1:-1, :])
+        self.assertEqual((slice(None, 1, -1), slice(1, 1, 1)), subscript[:1:-1, 1:1:1])
+        self.assertEqual((slice(None, 1, -1), slice(1, 1, None)), subscript[:1:-1, 1:1])
+        self.assertEqual((slice(None, 1, -1), slice(1, 1, None)), subscript[:1:-1, 1:1:])
+        self.assertEqual((slice(None, 1, -1), slice(1, None, 1)), subscript[:1:-1, 1::1])
+        self.assertEqual((slice(None, 1, -1), slice(1, None, None)), subscript[:1:-1, 1:])
+        self.assertEqual((slice(None, 1, -1), slice(1, None, None)), subscript[:1:-1, 1::])
+        self.assertEqual((slice(None, 1, -1), slice(None, 1, 1)), subscript[:1:-1, :1:1])
+        self.assertEqual((slice(None, 1, -1), slice(None, 1, None)), subscript[:1:-1, :1])
+        self.assertEqual((slice(None, 1, -1), slice(None, 1, None)), subscript[:1:-1, :1:])
+        self.assertEqual((slice(None, 1, -1), slice(-1, -1, -1)), subscript[:1:-1, -1:-1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, -1, None)), subscript[:1:-1, -1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, -1, None)), subscript[:1:-1, -1:-1:])
+        self.assertEqual((slice(None, 1, -1), slice(-1, None, -1)), subscript[:1:-1, -1::-1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, None, None)), subscript[:1:-1, -1:])
+        self.assertEqual((slice(None, 1, -1), slice(-1, None, None)), subscript[:1:-1, -1::])
+        self.assertEqual((slice(None, 1, -1), slice(None, -1, -1)), subscript[:1:-1, :-1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(None, -1, None)), subscript[:1:-1, :-1])
+        self.assertEqual((slice(None, 1, -1), slice(None, -1, None)), subscript[:1:-1, :-1:])
+        self.assertEqual((slice(None, 1, -1), slice(1, -1, -1)), subscript[:1:-1, 1:-1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, 1, -1)), subscript[:1:-1, -1:1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, -1, 1)), subscript[:1:-1, -1:-1:1])
+        self.assertEqual((slice(None, 1, -1), slice(1, 1, -1)), subscript[:1:-1, 1:1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(1, -1, 1)), subscript[:1:-1, 1:-1:1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, 1, 1)), subscript[:1:-1, -1:1:1])
+        self.assertEqual((slice(None, 1, -1), slice(1, -1, None)), subscript[:1:-1, 1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(1, -1, None)), subscript[:1:-1, 1:-1:])
+        self.assertEqual((slice(None, 1, -1), slice(-1, 1, None)), subscript[:1:-1, -1:1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, 1, None)), subscript[:1:-1, -1:1:])
+        self.assertEqual((slice(None, 1, -1), slice(1, None, -1)), subscript[:1:-1, 1::-1])
+        self.assertEqual((slice(None, 1, -1), slice(-1, None, 1)), subscript[:1:-1, -1::1])
+        self.assertEqual((slice(None, 1, -1), slice(None, 1, -1)), subscript[:1:-1, :1:-1])
+        self.assertEqual((slice(None, 1, -1), slice(None, -1, 1)), subscript[:1:-1, :-1:1])
+
+    def test_pickle(self):
+        from operator import subscript
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            with self.subTest(proto=proto):
+                self.assertIs(
+                    pickle.loads(pickle.dumps(subscript, proto)),
+                    subscript,
+                )
+
+    def test_singleton(self):
+        with self.assertRaises(TypeError):
+            type(self.module.subscript)()
+
+    def test_immutable(self):
+        with self.assertRaises(AttributeError):
+            self.module.subscript.attr = None
+
+
+class PySubscriptTestCase(SubscriptTestCase, PyOperatorTestCase):
+    pass
+
+
+class CSubscriptTestCase(SubscriptTestCase, COperatorTestCase):
+    pass
+
 if __name__ == "__main__":
     unittest.main()