diff -r 6d5d2bda6acb Doc/library/operator.rst
--- a/Doc/library/operator.rst	Wed Jun 03 11:11:22 2015 -0600
+++ b/Doc/library/operator.rst	Sun Jul 12 02:23:00 2015 -0400
@@ -333,6 +333,19 @@
       [('orange', 1), ('banana', 2), ('apple', 3), ('pear', 5)]
 
 
+.. data:: subscript
+
+    An object that may be subscripted to return the key.
+    This is useful for creating complex indexers to store and pass to
+    various subscriptable objects.  For example:
+
+    * ``subscript[:] == slice(None, None, None)``
+    * ``subscript[:, :] == (slice(None, None, None), slice(None, None, None))``
+    * ``subscript[k] == k``
+
+    .. versionadded:: 3.6
+
+
 .. function:: methodcaller(name[, args...])
 
    Return a callable object that calls the method *name* on its operand.  If
diff -r 6d5d2bda6acb Doc/whatsnew/3.6.rst
--- a/Doc/whatsnew/3.6.rst	Wed Jun 03 11:11:22 2015 -0600
+++ b/Doc/whatsnew/3.6.rst	Sun Jul 12 02:23:00 2015 -0400
@@ -95,7 +95,12 @@
 Improved Modules
 ================
 
-* None yet.
+operator
+--------
+
+* New object :data:`operator.subscript` makes it easier to create complex
+  indexers. For example: ``subscript[:] == slice(None, None, None)``
+  (Contributed by Joe Jevnik in :issue:`24379`.)
 
 
 Optimizations
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 02:23:00 2015 -0400
@@ -17,7 +17,7 @@
            'is_not', 'isub', 'itemgetter', 'itruediv', 'ixor', 'le',
            'length_hint', 'lshift', 'lt', 'methodcaller', 'mod', 'mul', 'ne',
            'neg', 'not_', 'or_', 'pos', 'pow', 'rshift', 'setitem', 'sub',
-           'truediv', 'truth', 'xor']
+           'subscript', 'truediv', 'truth', 'xor']
 
 from builtins import abs as _abs
 
@@ -408,6 +408,30 @@
     return a
 
 
+@object.__new__  # create a singleton instance
+class subscript:
+    """
+    An object that may be subscripted to return the key.
+    This is useful for creating complex indexers to store and pass to
+    various subscriptable objects.  For example:
+    subscript[:] == slice(None, None, None)
+    subscript[:, :] == (slice(None, None, None), slice(None, None, None))
+    subscript[k] == k
+    """
+    __slots__ = ()
+
+    def __new__(cls):
+        raise TypeError("cannot create '{}' instances".format(cls.__name__))
+
+    @staticmethod
+    def __getitem__(key):
+        return key
+
+    @staticmethod
+    def __reduce__():
+        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 02:23: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(subscript[None], None)
+        self.assertIs(subscript[''], '')
+        self.assertIs(subscript[5], 5)
+        self.assertEqual(subscript[:], slice(None, None, None))
+        self.assertEqual(subscript[::], slice(None, None, None))
+        self.assertEqual(subscript[1:1:1], slice(1, 1, 1))
+        self.assertEqual(subscript[1:1], slice(1, 1, None))
+        self.assertEqual(subscript[1:1:], slice(1, 1, None))
+        self.assertEqual(subscript[1::1], slice(1, None, 1))
+        self.assertEqual(subscript[1:], slice(1, None, None))
+        self.assertEqual(subscript[1::], slice(1, None, None))
+        self.assertEqual(subscript[:1:1], slice(None, 1, 1))
+        self.assertEqual(subscript[:1], slice(None, 1, None))
+        self.assertEqual(subscript[:1:], slice(None, 1, None))
+        self.assertEqual(subscript[-1:-1:-1], slice(-1, -1, -1))
+        self.assertEqual(subscript[-1:-1], slice(-1, -1, None))
+        self.assertEqual(subscript[-1:-1:], slice(-1, -1, None))
+        self.assertEqual(subscript[-1::-1], slice(-1, None, -1))
+        self.assertEqual(subscript[-1:], slice(-1, None, None))
+        self.assertEqual(subscript[-1::], slice(-1, None, None))
+        self.assertEqual(subscript[:-1:-1], slice(None, -1, -1))
+        self.assertEqual(subscript[:-1], slice(None, -1, None))
+        self.assertEqual(subscript[:-1:], slice(None, -1, None))
+        self.assertEqual(subscript[1:-1:-1], slice(1, -1, -1))
+        self.assertEqual(subscript[-1:1:-1], slice(-1, 1, -1))
+        self.assertEqual(subscript[-1:-1:1], slice(-1, -1, 1))
+        self.assertEqual(subscript[1:1:-1], slice(1, 1, -1))
+        self.assertEqual(subscript[1:-1:1], slice(1, -1, 1))
+        self.assertEqual(subscript[-1:1:1], slice(-1, 1, 1))
+        self.assertEqual(subscript[1:-1], slice(1, -1, None))
+        self.assertEqual(subscript[-1:1], slice(-1, 1, None))
+        self.assertEqual(subscript[1::-1], slice(1, None, -1))
+        self.assertEqual(subscript[-1::1], slice(-1, None, 1))
+        self.assertEqual(subscript[:1:-1], slice(None, 1, -1))
+        self.assertEqual(subscript[:-1:1], slice(None, -1, 1))
+        self.assertEqual(subscript[..., None], (Ellipsis, None))
+        self.assertEqual(subscript[..., ''], (Ellipsis, ''))
+        self.assertEqual(subscript[..., 5], (Ellipsis, 5))
+        self.assertEqual(subscript[..., :], (Ellipsis, slice(None, None, None)))
+        self.assertEqual(subscript[..., ::], (Ellipsis, slice(None, None, None)))
+        self.assertEqual(subscript[..., 1:1:1], (Ellipsis, slice(1, 1, 1)))
+        self.assertEqual(subscript[..., 1:1], (Ellipsis, slice(1, 1, None)))
+        self.assertEqual(subscript[..., 1::1], (Ellipsis, slice(1, None, 1)))
+        self.assertEqual(subscript[..., 1:], (Ellipsis, slice(1, None, None)))
+        self.assertEqual(subscript[..., 1::], (Ellipsis, slice(1, None, None)))
+        self.assertEqual(subscript[..., :1:1], (Ellipsis, slice(None, 1, 1)))
+        self.assertEqual(subscript[..., :1:], (Ellipsis, slice(None, 1, None)))
+        self.assertEqual(subscript[..., -1:-1:-1], (Ellipsis, slice(-1, -1, -1)))
+        self.assertEqual(subscript[..., -1:-1], (Ellipsis, slice(-1, -1, None)))
+        self.assertEqual(subscript[..., -1::-1], (Ellipsis, slice(-1, None, -1)))
+        self.assertEqual(subscript[..., -1:], (Ellipsis, slice(-1, None, None)))
+        self.assertEqual(subscript[..., -1::], (Ellipsis, slice(-1, None, None)))
+        self.assertEqual(subscript[..., :-1:-1], (Ellipsis, slice(None, -1, -1)))
+        self.assertEqual(subscript[..., 1:-1:-1], (Ellipsis, slice(1, -1, -1)))
+        self.assertEqual(subscript[..., -1:1:-1], (Ellipsis, slice(-1, 1, -1)))
+        self.assertEqual(subscript[..., -1:-1:1], (Ellipsis, slice(-1, -1, 1)))
+        self.assertEqual(subscript[..., 1:1:-1], (Ellipsis, slice(1, 1, -1)))
+        self.assertEqual(subscript[..., 1:-1:1], (Ellipsis, slice(1, -1, 1)))
+        self.assertEqual(subscript[..., -1:1:1], (Ellipsis, slice(-1, 1, 1)))
+        self.assertEqual(subscript[..., 1:-1], (Ellipsis, slice(1, -1, None)))
+        self.assertEqual(subscript[..., 1:-1:], (Ellipsis, slice(1, -1, None)))
+        self.assertEqual(subscript[..., -1:1], (Ellipsis, slice(-1, 1, None)))
+        self.assertEqual(subscript[..., -1:1:], (Ellipsis, slice(-1, 1, None)))
+        self.assertEqual(subscript[..., 1::-1], (Ellipsis, slice(1, None, -1)))
+        self.assertEqual(subscript[..., -1::1], (Ellipsis, slice(-1, None, 1)))
+        self.assertEqual(subscript[..., :1:-1], (Ellipsis, slice(None, 1, -1)))
+        self.assertEqual(subscript[..., :-1:1], (Ellipsis, slice(None, -1, 1)))
+        self.assertEqual(subscript[None, None], (None, None))
+        self.assertEqual(subscript[None, ''], (None, ''))
+        self.assertEqual(subscript[None, 5], (None, 5))
+        self.assertEqual(subscript[None, :], (None, slice(None, None, None)))
+        self.assertEqual(subscript[None, ::], (None, slice(None, None, None)))
+        self.assertEqual(subscript[None, 1:1:1], (None, slice(1, 1, 1)))
+        self.assertEqual(subscript[None, 1:1], (None, slice(1, 1, None)))
+        self.assertEqual(subscript[None, 1::1], (None, slice(1, None, 1)))
+        self.assertEqual(subscript[None, 1:], (None, slice(1, None, None)))
+        self.assertEqual(subscript[None, 1::], (None, slice(1, None, None)))
+        self.assertEqual(subscript[None, :1:1], (None, slice(None, 1, 1)))
+        self.assertEqual(subscript[None, :1:], (None, slice(None, 1, None)))
+        self.assertEqual(subscript[None, :1:], (None, slice(None, 1, None)))
+        self.assertEqual(subscript[None, -1:-1:-1], (None, slice(-1, -1, -1)))
+        self.assertEqual(subscript[None, -1:-1], (None, slice(-1, -1, None)))
+        self.assertEqual(subscript[None, -1:-1:], (None, slice(-1, -1, None)))
+        self.assertEqual(subscript[None, -1::-1], (None, slice(-1, None, -1)))
+        self.assertEqual(subscript[None, -1:], (None, slice(-1, None, None)))
+        self.assertEqual(subscript[None, -1::], (None, slice(-1, None, None)))
+        self.assertEqual(subscript[None, :-1:-1], (None, slice(None, -1, -1)))
+        self.assertEqual(subscript[None, :-1], (None, slice(None, -1, None)))
+        self.assertEqual(subscript[None, :-1:], (None, slice(None, -1, None)))
+        self.assertEqual(subscript[None, 1:-1:-1], (None, slice(1, -1, -1)))
+        self.assertEqual(subscript[None, -1:1:-1], (None, slice(-1, 1, -1)))
+        self.assertEqual(subscript[None, -1:-1:1], (None, slice(-1, -1, 1)))
+        self.assertEqual(subscript[None, 1:1:-1], (None, slice(1, 1, -1)))
+        self.assertEqual(subscript[None, 1:-1:1], (None, slice(1, -1, 1)))
+        self.assertEqual(subscript[None, -1:1:1], (None, slice(-1, 1, 1)))
+        self.assertEqual(subscript[None, 1:-1], (None, slice(1, -1, None)))
+        self.assertEqual(subscript[None, 1:-1:], (None, slice(1, -1, None)))
+        self.assertEqual(subscript[None, -1:1], (None, slice(-1, 1, None)))
+        self.assertEqual(subscript[None, -1:1:], (None, slice(-1, 1, None)))
+        self.assertEqual(subscript[None, 1::-1], (None, slice(1, None, -1)))
+        self.assertEqual(subscript[None, -1::1], (None, slice(-1, None, 1)))
+        self.assertEqual(subscript[None, :1:-1], (None, slice(None, 1, -1)))
+        self.assertEqual(subscript[None, :-1:1], (None, slice(None, -1, 1)))
+        self.assertEqual(subscript['', None], ('', None))
+        self.assertEqual(subscript['' ,''], ('', ''))
+        self.assertEqual(subscript['', 5], ('', 5))
+        self.assertEqual(subscript['', :], ('', slice(None, None, None)))
+        self.assertEqual(subscript['', 1:1:1], ('', slice(1, 1, 1)))
+        self.assertEqual(subscript['', 1:1], ('', slice(1, 1, None)))
+        self.assertEqual(subscript['', 1:1:], ('', slice(1, 1, None)))
+        self.assertEqual(subscript['', 1::1], ('', slice(1, None, 1)))
+        self.assertEqual(subscript['', 1:], ('', slice(1, None, None)))
+        self.assertEqual(subscript['', 1::], ('', slice(1, None, None)))
+        self.assertEqual(subscript['', :1:1], ('', slice(None, 1, 1)))
+        self.assertEqual(subscript['', :1], ('', slice(None, 1, None)))
+        self.assertEqual(subscript['', :1:], ('', slice(None, 1, None)))
+        self.assertEqual(subscript['', -1:-1:-1], ('', slice(-1, -1, -1)))
+        self.assertEqual(subscript['', -1:-1], ('', slice(-1, -1, None)))
+        self.assertEqual(subscript['', -1:-1:], ('', slice(-1, -1, None)))
+        self.assertEqual(subscript['', -1::-1], ('', slice(-1, None, -1)))
+        self.assertEqual(subscript['', -1:], ('', slice(-1, None, None)))
+        self.assertEqual(subscript['', -1::], ('', slice(-1, None, None)))
+        self.assertEqual(subscript['', :-1:-1], ('', slice(None, -1, -1)))
+        self.assertEqual(subscript['', :-1], ('', slice(None, -1, None)))
+        self.assertEqual(subscript['', :-1:], ('', slice(None, -1, None)))
+        self.assertEqual(subscript['', 1:-1:-1], ('', slice(1, -1, -1)))
+        self.assertEqual(subscript['', -1:1:-1], ('', slice(-1, 1, -1)))
+        self.assertEqual(subscript['', -1:-1:1], ('', slice(-1, -1, 1)))
+        self.assertEqual(subscript['', 1:1:-1], ('', slice(1, 1, -1)))
+        self.assertEqual(subscript['', 1:-1:1], ('', slice(1, -1, 1)))
+        self.assertEqual(subscript['', -1:1:1], ('', slice(-1, 1, 1)))
+        self.assertEqual(subscript['', 1:-1], ('', slice(1, -1, None)))
+        self.assertEqual(subscript['', 1:-1:], ('', slice(1, -1, None)))
+        self.assertEqual(subscript['', -1:1], ('', slice(-1, 1, None)))
+        self.assertEqual(subscript['', -1:1:], ('', slice(-1, 1, None)))
+        self.assertEqual(subscript['', 1::-1], ('', slice(1, None, -1)))
+        self.assertEqual(subscript['', -1::1], ('', slice(-1, None, 1)))
+        self.assertEqual(subscript['', :1:-1], ('', slice(None, 1, -1)))
+        self.assertEqual(subscript['', :-1:1], ('', slice(None, -1, 1)))
+        self.assertEqual(subscript[5, None], (5, None))
+        self.assertEqual(subscript[5 ,''], (5, ''))
+        self.assertEqual(subscript[5, 5], (5, 5))
+        self.assertEqual(subscript[5, :], (5, slice(None, None, None)))
+        self.assertEqual(subscript[5, 1:1:1], (5, slice(1, 1, 1)))
+        self.assertEqual(subscript[5, 1:1], (5, slice(1, 1, None)))
+        self.assertEqual(subscript[5, 1:1:], (5, slice(1, 1, None)))
+        self.assertEqual(subscript[5, 1::1], (5, slice(1, None, 1)))
+        self.assertEqual(subscript[5, 1:], (5, slice(1, None, None)))
+        self.assertEqual(subscript[5, 1::], (5, slice(1, None, None)))
+        self.assertEqual(subscript[5, :1:1], (5, slice(None, 1, 1)))
+        self.assertEqual(subscript[5, :1], (5, slice(None, 1, None)))
+        self.assertEqual(subscript[5, :1:], (5, slice(None, 1, None)))
+        self.assertEqual(subscript[5, -1:-1:-1], (5, slice(-1, -1, -1)))
+        self.assertEqual(subscript[5, -1:-1], (5, slice(-1, -1, None)))
+        self.assertEqual(subscript[5, -1:-1:], (5, slice(-1, -1, None)))
+        self.assertEqual(subscript[5, -1::-1], (5, slice(-1, None, -1)))
+        self.assertEqual(subscript[5, -1:], (5, slice(-1, None, None)))
+        self.assertEqual(subscript[5, -1::], (5, slice(-1, None, None)))
+        self.assertEqual(subscript[5, :-1:-1], (5, slice(None, -1, -1)))
+        self.assertEqual(subscript[5, :-1], (5, slice(None, -1, None)))
+        self.assertEqual(subscript[5, :-1:], (5, slice(None, -1, None)))
+        self.assertEqual(subscript[5, 1:-1:-1], (5, slice(1, -1, -1)))
+        self.assertEqual(subscript[5, -1:1:-1], (5, slice(-1, 1, -1)))
+        self.assertEqual(subscript[5, -1:-1:1], (5, slice(-1, -1, 1)))
+        self.assertEqual(subscript[5, 1:1:-1], (5, slice(1, 1, -1)))
+        self.assertEqual(subscript[5, 1:-1:1], (5, slice(1, -1, 1)))
+        self.assertEqual(subscript[5, -1:1:1], (5, slice(-1, 1, 1)))
+        self.assertEqual(subscript[5, 1:-1], (5, slice(1, -1, None)))
+        self.assertEqual(subscript[5, 1:-1:], (5, slice(1, -1, None)))
+        self.assertEqual(subscript[5, -1:1], (5, slice(-1, 1, None)))
+        self.assertEqual(subscript[5, -1:1:], (5, slice(-1, 1, None)))
+        self.assertEqual(subscript[5, 1::-1], (5, slice(1, None, -1)))
+        self.assertEqual(subscript[5, -1::1], (5, slice(-1, None, 1)))
+        self.assertEqual(subscript[5, :1:-1], (5, slice(None, 1, -1)))
+        self.assertEqual(subscript[5, :-1:1], (5, slice(None, -1, 1)))
+        self.assertEqual(subscript[:, None], (slice(None, None, None), None))
+        self.assertEqual(subscript[: ,''], (slice(None, None, None), ''))
+        self.assertEqual(subscript[:, 5], (slice(None, None, None), 5))
+        self.assertEqual(subscript[:, :], (slice(None, None, None), slice(None, None, None)))
+        self.assertEqual(subscript[:, 1:1:1], (slice(None, None, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[:, 1:1], (slice(None, None, None), slice(1, 1, None)))
+        self.assertEqual(subscript[:, 1:1:], (slice(None, None, None), slice(1, 1, None)))
+        self.assertEqual(subscript[:, 1::1], (slice(None, None, None), slice(1, None, 1)))
+        self.assertEqual(subscript[:, 1:], (slice(None, None, None), slice(1, None, None)))
+        self.assertEqual(subscript[:, 1::], (slice(None, None, None), slice(1, None, None)))
+        self.assertEqual(subscript[:, :1:1], (slice(None, None, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[:, :1], (slice(None, None, None), slice(None, 1, None)))
+        self.assertEqual(subscript[:, :1:], (slice(None, None, None), slice(None, 1, None)))
+        self.assertEqual(subscript[:, -1:-1:-1], (slice(None, None, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[:, -1:-1], (slice(None, None, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[:, -1:-1:], (slice(None, None, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[:, -1::-1], (slice(None, None, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[:, -1:], (slice(None, None, None), slice(-1, None, None)))
+        self.assertEqual(subscript[:, -1::], (slice(None, None, None), slice(-1, None, None)))
+        self.assertEqual(subscript[:, :-1:-1], (slice(None, None, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[:, :-1], (slice(None, None, None), slice(None, -1, None)))
+        self.assertEqual(subscript[:, :-1:], (slice(None, None, None), slice(None, -1, None)))
+        self.assertEqual(subscript[:, 1:-1:-1], (slice(None, None, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[:, -1:1:-1], (slice(None, None, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[:, -1:-1:1], (slice(None, None, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[:, 1:1:-1], (slice(None, None, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[:, 1:-1:1], (slice(None, None, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[:, -1:1:1], (slice(None, None, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[:, 1:-1], (slice(None, None, None), slice(1, -1, None)))
+        self.assertEqual(subscript[:, 1:-1:], (slice(None, None, None), slice(1, -1, None)))
+        self.assertEqual(subscript[:, -1:1], (slice(None, None, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[:, -1:1:], (slice(None, None, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[:, 1::-1], (slice(None, None, None), slice(1, None, -1)))
+        self.assertEqual(subscript[:, -1::1], (slice(None, None, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[:, :1:-1], (slice(None, None, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[:, :-1:1], (slice(None, None, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[1:1:1, None], (slice(1, 1, 1), None))
+        self.assertEqual(subscript[1:1:1 ,''], (slice(1, 1, 1), ''))
+        self.assertEqual(subscript[1:1:1, 5], (slice(1, 1, 1), 5))
+        self.assertEqual(subscript[1:1:1, :], (slice(1, 1, 1), slice(None, None, None)))
+        self.assertEqual(subscript[1:1:1, 1:1:1], (slice(1, 1, 1), slice(1, 1, 1)))
+        self.assertEqual(subscript[1:1:1, 1:1], (slice(1, 1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:1:1, 1:1:], (slice(1, 1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:1:1, 1::1], (slice(1, 1, 1), slice(1, None, 1)))
+        self.assertEqual(subscript[1:1:1, 1:], (slice(1, 1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[1:1:1, 1::], (slice(1, 1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[1:1:1, :1:1], (slice(1, 1, 1), slice(None, 1, 1)))
+        self.assertEqual(subscript[1:1:1, :1], (slice(1, 1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:1:1, :1:], (slice(1, 1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:1:1, -1:-1:-1], (slice(1, 1, 1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1:1:1, -1:-1], (slice(1, 1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:1:1, -1:-1:], (slice(1, 1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:1:1, -1::-1], (slice(1, 1, 1), slice(-1, None, -1)))
+        self.assertEqual(subscript[1:1:1, -1:], (slice(1, 1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:1:1, -1::], (slice(1, 1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:1:1, :-1:-1], (slice(1, 1, 1), slice(None, -1, -1)))
+        self.assertEqual(subscript[1:1:1, :-1], (slice(1, 1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:1:1, :-1:], (slice(1, 1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:1:1, 1:-1:-1], (slice(1, 1, 1), slice(1, -1, -1)))
+        self.assertEqual(subscript[1:1:1, -1:1:-1], (slice(1, 1, 1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1:1:1, -1:-1:1], (slice(1, 1, 1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1:1:1, 1:1:-1], (slice(1, 1, 1), slice(1, 1, -1)))
+        self.assertEqual(subscript[1:1:1, 1:-1:1], (slice(1, 1, 1), slice(1, -1, 1)))
+        self.assertEqual(subscript[1:1:1, -1:1:1], (slice(1, 1, 1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1:1:1, 1:-1], (slice(1, 1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:1:1, 1:-1:], (slice(1, 1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:1:1, -1:1], (slice(1, 1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:1:1, -1:1:], (slice(1, 1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:1:1, 1::-1], (slice(1, 1, 1), slice(1, None, -1)))
+        self.assertEqual(subscript[1:1:1, -1::1], (slice(1, 1, 1), slice(-1, None, 1)))
+        self.assertEqual(subscript[1:1:1, :1:-1], (slice(1, 1, 1), slice(None, 1, -1)))
+        self.assertEqual(subscript[1:1:1, :-1:1], (slice(1, 1, 1), slice(None, -1, 1)))
+        self.assertEqual(subscript[1:1, None], (slice(1, 1, None), None))
+        self.assertEqual(subscript[1:1 ,''], (slice(1, 1, None), ''))
+        self.assertEqual(subscript[1:1, 5], (slice(1, 1, None), 5))
+        self.assertEqual(subscript[1:1, :], (slice(1, 1, None), slice(None, None, None)))
+        self.assertEqual(subscript[1:1, 1:1:1], (slice(1, 1, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[1:1, 1:1], (slice(1, 1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[1:1, 1:1:], (slice(1, 1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[1:1, 1::1], (slice(1, 1, None), slice(1, None, 1)))
+        self.assertEqual(subscript[1:1, 1:], (slice(1, 1, None), slice(1, None, None)))
+        self.assertEqual(subscript[1:1, 1::], (slice(1, 1, None), slice(1, None, None)))
+        self.assertEqual(subscript[1:1, :1:1], (slice(1, 1, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[1:1, :1], (slice(1, 1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[1:1, :1:], (slice(1, 1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[1:1, -1:-1:-1], (slice(1, 1, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1:1, -1:-1], (slice(1, 1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:1, -1:-1:], (slice(1, 1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:1, -1::-1], (slice(1, 1, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[1:1, -1:], (slice(1, 1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[1:1, -1::], (slice(1, 1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[1:1, :-1:-1], (slice(1, 1, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[1:1, :-1], (slice(1, 1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[1:1, :-1:], (slice(1, 1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[1:1, 1:-1:-1], (slice(1, 1, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[1:1, -1:1:-1], (slice(1, 1, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1:1, -1:-1:1], (slice(1, 1, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1:1, 1:1:-1], (slice(1, 1, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[1:1, 1:-1:1], (slice(1, 1, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[1:1, -1:1:1], (slice(1, 1, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1:1, 1:-1], (slice(1, 1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[1:1, 1:-1:], (slice(1, 1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[1:1, -1:1], (slice(1, 1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:1, -1:1:], (slice(1, 1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:1, 1::-1], (slice(1, 1, None), slice(1, None, -1)))
+        self.assertEqual(subscript[1:1, -1::1], (slice(1, 1, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[1:1, :1:-1], (slice(1, 1, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[1:1, :-1:1], (slice(1, 1, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[1:, None], (slice(1, None, None), None))
+        self.assertEqual(subscript[1: ,''], (slice(1, None, None), ''))
+        self.assertEqual(subscript[1:, 5], (slice(1, None, None), 5))
+        self.assertEqual(subscript[1:, :], (slice(1, None, None), slice(None, None, None)))
+        self.assertEqual(subscript[1:, 1:1:1], (slice(1, None, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[1:, 1:1], (slice(1, None, None), slice(1, 1, None)))
+        self.assertEqual(subscript[1:, 1:1:], (slice(1, None, None), slice(1, 1, None)))
+        self.assertEqual(subscript[1:, 1::1], (slice(1, None, None), slice(1, None, 1)))
+        self.assertEqual(subscript[1:, 1:], (slice(1, None, None), slice(1, None, None)))
+        self.assertEqual(subscript[1:, 1::], (slice(1, None, None), slice(1, None, None)))
+        self.assertEqual(subscript[1:, :1:1], (slice(1, None, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[1:, :1], (slice(1, None, None), slice(None, 1, None)))
+        self.assertEqual(subscript[1:, :1:], (slice(1, None, None), slice(None, 1, None)))
+        self.assertEqual(subscript[1:, -1:-1:-1], (slice(1, None, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1:, -1:-1], (slice(1, None, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:, -1:-1:], (slice(1, None, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:, -1::-1], (slice(1, None, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[1:, -1:], (slice(1, None, None), slice(-1, None, None)))
+        self.assertEqual(subscript[1:, -1::], (slice(1, None, None), slice(-1, None, None)))
+        self.assertEqual(subscript[1:, :-1:-1], (slice(1, None, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[1:, :-1], (slice(1, None, None), slice(None, -1, None)))
+        self.assertEqual(subscript[1:, :-1:], (slice(1, None, None), slice(None, -1, None)))
+        self.assertEqual(subscript[1:, 1:-1:-1], (slice(1, None, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[1:, -1:1:-1], (slice(1, None, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1:, -1:-1:1], (slice(1, None, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1:, 1:1:-1], (slice(1, None, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[1:, 1:-1:1], (slice(1, None, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[1:, -1:1:1], (slice(1, None, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1:, 1:-1], (slice(1, None, None), slice(1, -1, None)))
+        self.assertEqual(subscript[1:, 1:-1:], (slice(1, None, None), slice(1, -1, None)))
+        self.assertEqual(subscript[1:, -1:1], (slice(1, None, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:, -1:1:], (slice(1, None, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:, 1::-1], (slice(1, None, None), slice(1, None, -1)))
+        self.assertEqual(subscript[1:, -1::1], (slice(1, None, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[1:, :1:-1], (slice(1, None, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[1:, :-1:1], (slice(1, None, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[:1:1, None], (slice(None, 1, 1), None))
+        self.assertEqual(subscript[:1:1 ,''], (slice(None, 1, 1), ''))
+        self.assertEqual(subscript[:1:1, 5], (slice(None, 1, 1), 5))
+        self.assertEqual(subscript[:1:1, :], (slice(None, 1, 1), slice(None, None, None)))
+        self.assertEqual(subscript[:1:1, 1:1:1], (slice(None, 1, 1), slice(1, 1, 1)))
+        self.assertEqual(subscript[:1:1, 1:1], (slice(None, 1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[:1:1, 1:1:], (slice(None, 1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[:1:1, 1::1], (slice(None, 1, 1), slice(1, None, 1)))
+        self.assertEqual(subscript[:1:1, 1:], (slice(None, 1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[:1:1, 1::], (slice(None, 1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[:1:1, :1:1], (slice(None, 1, 1), slice(None, 1, 1)))
+        self.assertEqual(subscript[:1:1, :1], (slice(None, 1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[:1:1, :1:], (slice(None, 1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[:1:1, -1:-1:-1], (slice(None, 1, 1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[:1:1, -1:-1], (slice(None, 1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[:1:1, -1:-1:], (slice(None, 1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[:1:1, -1::-1], (slice(None, 1, 1), slice(-1, None, -1)))
+        self.assertEqual(subscript[:1:1, -1:], (slice(None, 1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[:1:1, -1::], (slice(None, 1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[:1:1, :-1:-1], (slice(None, 1, 1), slice(None, -1, -1)))
+        self.assertEqual(subscript[:1:1, :-1], (slice(None, 1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[:1:1, :-1:], (slice(None, 1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[:1:1, 1:-1:-1], (slice(None, 1, 1), slice(1, -1, -1)))
+        self.assertEqual(subscript[:1:1, -1:1:-1], (slice(None, 1, 1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[:1:1, -1:-1:1], (slice(None, 1, 1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[:1:1, 1:1:-1], (slice(None, 1, 1), slice(1, 1, -1)))
+        self.assertEqual(subscript[:1:1, 1:-1:1], (slice(None, 1, 1), slice(1, -1, 1)))
+        self.assertEqual(subscript[:1:1, -1:1:1], (slice(None, 1, 1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[:1:1, 1:-1], (slice(None, 1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[:1:1, 1:-1:], (slice(None, 1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[:1:1, -1:1], (slice(None, 1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[:1:1, -1:1:], (slice(None, 1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[:1:1, 1::-1], (slice(None, 1, 1), slice(1, None, -1)))
+        self.assertEqual(subscript[:1:1, -1::1], (slice(None, 1, 1), slice(-1, None, 1)))
+        self.assertEqual(subscript[:1:1, :1:-1], (slice(None, 1, 1), slice(None, 1, -1)))
+        self.assertEqual(subscript[:1:1, :-1:1], (slice(None, 1, 1), slice(None, -1, 1)))
+        self.assertEqual(subscript[:1, None], (slice(None, 1, None), None))
+        self.assertEqual(subscript[:1 ,''], (slice(None, 1, None), ''))
+        self.assertEqual(subscript[:1, 5], (slice(None, 1, None), 5))
+        self.assertEqual(subscript[:1, :], (slice(None, 1, None), slice(None, None, None)))
+        self.assertEqual(subscript[:1, 1:1:1], (slice(None, 1, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[:1, 1:1], (slice(None, 1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[:1, 1:1:], (slice(None, 1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[:1, 1::1], (slice(None, 1, None), slice(1, None, 1)))
+        self.assertEqual(subscript[:1, 1:], (slice(None, 1, None), slice(1, None, None)))
+        self.assertEqual(subscript[:1, 1::], (slice(None, 1, None), slice(1, None, None)))
+        self.assertEqual(subscript[:1, :1:1], (slice(None, 1, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[:1, :1], (slice(None, 1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[:1, :1:], (slice(None, 1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[:1, -1:-1:-1], (slice(None, 1, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[:1, -1:-1], (slice(None, 1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[:1, -1:-1:], (slice(None, 1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[:1, -1::-1], (slice(None, 1, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[:1, -1:], (slice(None, 1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[:1, -1::], (slice(None, 1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[:1, :-1:-1], (slice(None, 1, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[:1, :-1], (slice(None, 1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[:1, :-1:], (slice(None, 1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[:1, 1:-1:-1], (slice(None, 1, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[:1, -1:1:-1], (slice(None, 1, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[:1, -1:-1:1], (slice(None, 1, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[:1, 1:1:-1], (slice(None, 1, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[:1, 1:-1:1], (slice(None, 1, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[:1, -1:1:1], (slice(None, 1, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[:1, 1:-1], (slice(None, 1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[:1, 1:-1:], (slice(None, 1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[:1, -1:1], (slice(None, 1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[:1, -1:1:], (slice(None, 1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[:1, 1::-1], (slice(None, 1, None), slice(1, None, -1)))
+        self.assertEqual(subscript[:1, -1::1], (slice(None, 1, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[:1, :1:-1], (slice(None, 1, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[:1, :-1:1], (slice(None, 1, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1:-1:-1, None], (slice(-1, -1, -1), None))
+        self.assertEqual(subscript[-1:-1:-1 ,''], (slice(-1, -1, -1), ''))
+        self.assertEqual(subscript[-1:-1:-1, 5], (slice(-1, -1, -1), 5))
+        self.assertEqual(subscript[-1:-1:-1, :], (slice(-1, -1, -1), slice(None, None, None)))
+        self.assertEqual(subscript[-1:-1:-1, 1:1:1], (slice(-1, -1, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1:-1:-1, 1:1], (slice(-1, -1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:-1:-1, 1:1:], (slice(-1, -1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:-1:-1, 1::1], (slice(-1, -1, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[-1:-1:-1, 1:], (slice(-1, -1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:-1:-1, 1::], (slice(-1, -1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:-1:-1, :1:1], (slice(-1, -1, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1:-1:-1, :1], (slice(-1, -1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:-1:-1, :1:], (slice(-1, -1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:-1:-1, -1:-1:-1], (slice(-1, -1, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1:-1:-1, -1:-1], (slice(-1, -1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:-1:-1, -1:-1:], (slice(-1, -1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:-1:-1, -1::-1], (slice(-1, -1, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1:-1:-1, -1:], (slice(-1, -1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:-1:-1, -1::], (slice(-1, -1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:-1:-1, :-1:-1], (slice(-1, -1, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1:-1:-1, :-1], (slice(-1, -1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:-1:-1, :-1:], (slice(-1, -1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:-1:-1, 1:-1:-1], (slice(-1, -1, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1:-1:-1, -1:1:-1], (slice(-1, -1, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1:-1:-1, -1:-1:1], (slice(-1, -1, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1:-1:-1, 1:1:-1], (slice(-1, -1, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1:-1:-1, 1:-1:1], (slice(-1, -1, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1:-1:-1, -1:1:1], (slice(-1, -1, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1:-1:-1, 1:-1], (slice(-1, -1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:-1:-1, 1:-1:], (slice(-1, -1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:-1:-1, -1:1], (slice(-1, -1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:-1:-1, -1:1:], (slice(-1, -1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:-1:-1, 1::-1], (slice(-1, -1, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[-1:-1:-1, -1::1], (slice(-1, -1, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1:-1:-1, :1:-1], (slice(-1, -1, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1:-1:-1, :-1:1], (slice(-1, -1, -1), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1:-1, None], (slice(-1, -1, None), None))
+        self.assertEqual(subscript[-1:-1 ,''], (slice(-1, -1, None), ''))
+        self.assertEqual(subscript[-1:-1, 5], (slice(-1, -1, None), 5))
+        self.assertEqual(subscript[-1:-1, :], (slice(-1, -1, None), slice(None, None, None)))
+        self.assertEqual(subscript[-1:-1, 1:1:1], (slice(-1, -1, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1:-1, 1:1], (slice(-1, -1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:-1, 1:1:], (slice(-1, -1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:-1, 1::1], (slice(-1, -1, None), slice(1, None, 1)))
+        self.assertEqual(subscript[-1:-1, 1:], (slice(-1, -1, None), slice(1, None, None)))
+        self.assertEqual(subscript[-1:-1, 1::], (slice(-1, -1, None), slice(1, None, None)))
+        self.assertEqual(subscript[-1:-1, :1:1], (slice(-1, -1, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1:-1, :1], (slice(-1, -1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:-1, :1:], (slice(-1, -1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:-1, -1:-1:-1], (slice(-1, -1, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1:-1, -1:-1], (slice(-1, -1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:-1, -1:-1:], (slice(-1, -1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:-1, -1::-1], (slice(-1, -1, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1:-1, -1:], (slice(-1, -1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:-1, -1::], (slice(-1, -1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:-1, :-1:-1], (slice(-1, -1, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1:-1, :-1], (slice(-1, -1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:-1, :-1:], (slice(-1, -1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:-1, 1:-1:-1], (slice(-1, -1, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1:-1, -1:1:-1], (slice(-1, -1, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1:-1, -1:-1:1], (slice(-1, -1, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1:-1, 1:1:-1], (slice(-1, -1, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1:-1, 1:-1:1], (slice(-1, -1, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1:-1, -1:1:1], (slice(-1, -1, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1:-1, 1:-1], (slice(-1, -1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:-1, 1:-1:], (slice(-1, -1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:-1, -1:1], (slice(-1, -1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:-1, -1:1:], (slice(-1, -1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:-1, 1::-1], (slice(-1, -1, None), slice(1, None, -1)))
+        self.assertEqual(subscript[-1:-1, -1::1], (slice(-1, -1, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1:-1, :1:-1], (slice(-1, -1, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1:-1, :-1:1], (slice(-1, -1, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1::-1, None], (slice(-1, None, -1), None))
+        self.assertEqual(subscript[-1::-1 ,''], (slice(-1, None, -1), ''))
+        self.assertEqual(subscript[-1::-1, 5], (slice(-1, None, -1), 5))
+        self.assertEqual(subscript[-1::-1, :], (slice(-1, None, -1), slice(None, None, None)))
+        self.assertEqual(subscript[-1::-1, 1:1:1], (slice(-1, None, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1::-1, 1:1], (slice(-1, None, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1::-1, 1:1:], (slice(-1, None, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1::-1, 1::1], (slice(-1, None, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[-1::-1, 1:], (slice(-1, None, -1), slice(1, None, None)))
+        self.assertEqual(subscript[-1::-1, 1::], (slice(-1, None, -1), slice(1, None, None)))
+        self.assertEqual(subscript[-1::-1, :1:1], (slice(-1, None, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1::-1, :1], (slice(-1, None, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1::-1, :1:], (slice(-1, None, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1::-1, -1:-1:-1], (slice(-1, None, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1::-1, -1:-1], (slice(-1, None, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1::-1, -1:-1:], (slice(-1, None, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1::-1, -1::-1], (slice(-1, None, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1::-1, -1:], (slice(-1, None, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1::-1, -1::], (slice(-1, None, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1::-1, :-1:-1], (slice(-1, None, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1::-1, :-1], (slice(-1, None, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1::-1, :-1:], (slice(-1, None, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1::-1, 1:-1:-1], (slice(-1, None, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1::-1, -1:1:-1], (slice(-1, None, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1::-1, -1:-1:1], (slice(-1, None, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1::-1, 1:1:-1], (slice(-1, None, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1::-1, 1:-1:1], (slice(-1, None, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1::-1, -1:1:1], (slice(-1, None, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1::-1, 1:-1], (slice(-1, None, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1::-1, 1:-1:], (slice(-1, None, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1::-1, -1:1], (slice(-1, None, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1::-1, -1:1:], (slice(-1, None, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1::-1, 1::-1], (slice(-1, None, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[-1::-1, -1::1], (slice(-1, None, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1::-1, :1:-1], (slice(-1, None, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1::-1, :-1:1], (slice(-1, None, -1), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1:, None], (slice(-1, None, None), None))
+        self.assertEqual(subscript[-1: ,''], (slice(-1, None, None), ''))
+        self.assertEqual(subscript[-1:, 5], (slice(-1, None, None), 5))
+        self.assertEqual(subscript[-1:, :], (slice(-1, None, None), slice(None, None, None)))
+        self.assertEqual(subscript[-1:, 1:1:1], (slice(-1, None, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1:, 1:1], (slice(-1, None, None), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:, 1:1:], (slice(-1, None, None), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:, 1::1], (slice(-1, None, None), slice(1, None, 1)))
+        self.assertEqual(subscript[-1:, 1:], (slice(-1, None, None), slice(1, None, None)))
+        self.assertEqual(subscript[-1:, 1::], (slice(-1, None, None), slice(1, None, None)))
+        self.assertEqual(subscript[-1:, :1:1], (slice(-1, None, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1:, :1], (slice(-1, None, None), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:, :1:], (slice(-1, None, None), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:, -1:-1:-1], (slice(-1, None, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1:, -1:-1], (slice(-1, None, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:, -1:-1:], (slice(-1, None, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:, -1::-1], (slice(-1, None, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1:, -1:], (slice(-1, None, None), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:, -1::], (slice(-1, None, None), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:, :-1:-1], (slice(-1, None, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1:, :-1], (slice(-1, None, None), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:, :-1:], (slice(-1, None, None), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:, 1:-1:-1], (slice(-1, None, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1:, -1:1:-1], (slice(-1, None, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1:, -1:-1:1], (slice(-1, None, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1:, 1:1:-1], (slice(-1, None, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1:, 1:-1:1], (slice(-1, None, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1:, -1:1:1], (slice(-1, None, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1:, 1:-1], (slice(-1, None, None), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:, 1:-1:], (slice(-1, None, None), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:, -1:1], (slice(-1, None, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:, -1:1:], (slice(-1, None, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:, 1::-1], (slice(-1, None, None), slice(1, None, -1)))
+        self.assertEqual(subscript[-1:, -1::1], (slice(-1, None, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1:, :1:-1], (slice(-1, None, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1:, :-1:1], (slice(-1, None, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[:-1:-1, None], (slice(None, -1, -1), None))
+        self.assertEqual(subscript[:-1:-1 ,''], (slice(None, -1, -1), ''))
+        self.assertEqual(subscript[:-1:-1, 5], (slice(None, -1, -1), 5))
+        self.assertEqual(subscript[:-1:-1, :], (slice(None, -1, -1), slice(None, None, None)))
+        self.assertEqual(subscript[:-1:-1, 1:1:1], (slice(None, -1, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[:-1:-1, 1:1], (slice(None, -1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[:-1:-1, 1:1:], (slice(None, -1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[:-1:-1, 1::1], (slice(None, -1, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[:-1:-1, 1:], (slice(None, -1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[:-1:-1, 1::], (slice(None, -1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[:-1:-1, :1:1], (slice(None, -1, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[:-1:-1, :1], (slice(None, -1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[:-1:-1, :1:], (slice(None, -1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[:-1:-1, -1:-1:-1], (slice(None, -1, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[:-1:-1, -1:-1], (slice(None, -1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[:-1:-1, -1:-1:], (slice(None, -1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[:-1:-1, -1::-1], (slice(None, -1, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[:-1:-1, -1:], (slice(None, -1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[:-1:-1, -1::], (slice(None, -1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[:-1:-1, :-1:-1], (slice(None, -1, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[:-1:-1, :-1], (slice(None, -1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[:-1:-1, :-1:], (slice(None, -1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[:-1:-1, 1:-1:-1], (slice(None, -1, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[:-1:-1, -1:1:-1], (slice(None, -1, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[:-1:-1, -1:-1:1], (slice(None, -1, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[:-1:-1, 1:1:-1], (slice(None, -1, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[:-1:-1, 1:-1:1], (slice(None, -1, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[:-1:-1, -1:1:1], (slice(None, -1, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[:-1:-1, 1:-1], (slice(None, -1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[:-1:-1, 1:-1:], (slice(None, -1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[:-1:-1, -1:1], (slice(None, -1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[:-1:-1, -1:1:], (slice(None, -1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[:-1:-1, 1::-1], (slice(None, -1, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[:-1:-1, -1::1], (slice(None, -1, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[:-1:-1, :1:-1], (slice(None, -1, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[:-1:-1, :-1:1], (slice(None, -1, -1), slice(None, -1, 1)))
+        self.assertEqual(subscript[:-1, None], (slice(None, -1, None), None))
+        self.assertEqual(subscript[:-1 ,''], (slice(None, -1, None), ''))
+        self.assertEqual(subscript[:-1, 5], (slice(None, -1, None), 5))
+        self.assertEqual(subscript[:-1, :], (slice(None, -1, None), slice(None, None, None)))
+        self.assertEqual(subscript[:-1, 1:1:1], (slice(None, -1, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[:-1, 1:1], (slice(None, -1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[:-1, 1:1:], (slice(None, -1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[:-1, 1::1], (slice(None, -1, None), slice(1, None, 1)))
+        self.assertEqual(subscript[:-1, 1:], (slice(None, -1, None), slice(1, None, None)))
+        self.assertEqual(subscript[:-1, 1::], (slice(None, -1, None), slice(1, None, None)))
+        self.assertEqual(subscript[:-1, :1:1], (slice(None, -1, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[:-1, :1], (slice(None, -1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[:-1, :1:], (slice(None, -1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[:-1, -1:-1:-1], (slice(None, -1, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[:-1, -1:-1], (slice(None, -1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[:-1, -1:-1:], (slice(None, -1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[:-1, -1::-1], (slice(None, -1, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[:-1, -1:], (slice(None, -1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[:-1, -1::], (slice(None, -1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[:-1, :-1:-1], (slice(None, -1, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[:-1, :-1], (slice(None, -1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[:-1, :-1:], (slice(None, -1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[:-1, 1:-1:-1], (slice(None, -1, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[:-1, -1:1:-1], (slice(None, -1, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[:-1, -1:-1:1], (slice(None, -1, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[:-1, 1:1:-1], (slice(None, -1, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[:-1, 1:-1:1], (slice(None, -1, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[:-1, -1:1:1], (slice(None, -1, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[:-1, 1:-1], (slice(None, -1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[:-1, 1:-1:], (slice(None, -1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[:-1, -1:1], (slice(None, -1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[:-1, -1:1:], (slice(None, -1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[:-1, 1::-1], (slice(None, -1, None), slice(1, None, -1)))
+        self.assertEqual(subscript[:-1, -1::1], (slice(None, -1, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[:-1, :1:-1], (slice(None, -1, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[:-1, :-1:1], (slice(None, -1, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[1:-1:-1, None], (slice(1, -1, -1), None))
+        self.assertEqual(subscript[1:-1:-1 ,''], (slice(1, -1, -1), ''))
+        self.assertEqual(subscript[1:-1:-1, 5], (slice(1, -1, -1), 5))
+        self.assertEqual(subscript[1:-1:-1, :], (slice(1, -1, -1), slice(None, None, None)))
+        self.assertEqual(subscript[1:-1:-1, 1:1:1], (slice(1, -1, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[1:-1:-1, 1:1], (slice(1, -1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:-1:-1, 1:1:], (slice(1, -1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:-1:-1, 1::1], (slice(1, -1, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[1:-1:-1, 1:], (slice(1, -1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[1:-1:-1, 1::], (slice(1, -1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[1:-1:-1, :1:1], (slice(1, -1, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[1:-1:-1, :1], (slice(1, -1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:-1:-1, :1:], (slice(1, -1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:-1:-1, -1:-1:-1], (slice(1, -1, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1:-1:-1, -1:-1], (slice(1, -1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:-1:-1, -1:-1:], (slice(1, -1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:-1:-1, -1::-1], (slice(1, -1, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[1:-1:-1, -1:], (slice(1, -1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:-1:-1, -1::], (slice(1, -1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:-1:-1, :-1:-1], (slice(1, -1, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[1:-1:-1, :-1], (slice(1, -1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:-1:-1, :-1:], (slice(1, -1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:-1:-1, 1:-1:-1], (slice(1, -1, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[1:-1:-1, -1:1:-1], (slice(1, -1, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1:-1:-1, -1:-1:1], (slice(1, -1, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1:-1:-1, 1:1:-1], (slice(1, -1, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[1:-1:-1, 1:-1:1], (slice(1, -1, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[1:-1:-1, -1:1:1], (slice(1, -1, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1:-1:-1, 1:-1], (slice(1, -1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:-1:-1, 1:-1:], (slice(1, -1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:-1:-1, -1:1], (slice(1, -1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:-1:-1, -1:1:], (slice(1, -1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:-1:-1, 1::-1], (slice(1, -1, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[1:-1:-1, -1::1], (slice(1, -1, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[1:-1:-1, :1:-1], (slice(1, -1, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[1:-1:-1, :-1:1], (slice(1, -1, -1), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1:1:-1, None], (slice(-1, 1, -1), None))
+        self.assertEqual(subscript[-1:1:-1 ,''], (slice(-1, 1, -1), ''))
+        self.assertEqual(subscript[-1:1:-1, 5], (slice(-1, 1, -1), 5))
+        self.assertEqual(subscript[-1:1:-1, :], (slice(-1, 1, -1), slice(None, None, None)))
+        self.assertEqual(subscript[-1:1:-1, 1:1:1], (slice(-1, 1, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1:1:-1, 1:1], (slice(-1, 1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:1:-1, 1:1:], (slice(-1, 1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:1:-1, 1::1], (slice(-1, 1, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[-1:1:-1, 1:], (slice(-1, 1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:1:-1, 1::], (slice(-1, 1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:1:-1, :1:1], (slice(-1, 1, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1:1:-1, :1], (slice(-1, 1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:1:-1, :1:], (slice(-1, 1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:1:-1, -1:-1:-1], (slice(-1, 1, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1:1:-1, -1:-1], (slice(-1, 1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:1:-1, -1:-1:], (slice(-1, 1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:1:-1, -1::-1], (slice(-1, 1, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1:1:-1, -1:], (slice(-1, 1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:1:-1, -1::], (slice(-1, 1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:1:-1, :-1:-1], (slice(-1, 1, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1:1:-1, :-1], (slice(-1, 1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:1:-1, :-1:], (slice(-1, 1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:1:-1, 1:-1:-1], (slice(-1, 1, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1:1:-1, -1:1:-1], (slice(-1, 1, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1:1:-1, -1:-1:1], (slice(-1, 1, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1:1:-1, 1:1:-1], (slice(-1, 1, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1:1:-1, 1:-1:1], (slice(-1, 1, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1:1:-1, -1:1:1], (slice(-1, 1, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1:1:-1, 1:-1], (slice(-1, 1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:1:-1, 1:-1:], (slice(-1, 1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:1:-1, -1:1], (slice(-1, 1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:1:-1, -1:1:], (slice(-1, 1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:1:-1, 1::-1], (slice(-1, 1, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[-1:1:-1, -1::1], (slice(-1, 1, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1:1:-1, :1:-1], (slice(-1, 1, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1:1:-1, :-1:1], (slice(-1, 1, -1), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1:-1:1, None], (slice(-1, -1, 1), None))
+        self.assertEqual(subscript[-1:-1:1 ,''], (slice(-1, -1, 1), ''))
+        self.assertEqual(subscript[-1:-1:1, 5], (slice(-1, -1, 1), 5))
+        self.assertEqual(subscript[-1:-1:1, :], (slice(-1, -1, 1), slice(None, None, None)))
+        self.assertEqual(subscript[-1:-1:1, 1:1:1], (slice(-1, -1, 1), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1:-1:1, 1:1], (slice(-1, -1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:-1:1, 1:1:], (slice(-1, -1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:-1:1, 1::1], (slice(-1, -1, 1), slice(1, None, 1)))
+        self.assertEqual(subscript[-1:-1:1, 1:], (slice(-1, -1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:-1:1, 1::], (slice(-1, -1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:-1:1, :1:1], (slice(-1, -1, 1), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1:-1:1, :1], (slice(-1, -1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:-1:1, :1:], (slice(-1, -1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:-1:1, -1:-1:-1], (slice(-1, -1, 1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1:-1:1, -1:-1], (slice(-1, -1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:-1:1, -1:-1:], (slice(-1, -1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:-1:1, -1::-1], (slice(-1, -1, 1), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1:-1:1, -1:], (slice(-1, -1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:-1:1, -1::], (slice(-1, -1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:-1:1, :-1:-1], (slice(-1, -1, 1), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1:-1:1, :-1], (slice(-1, -1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:-1:1, :-1:], (slice(-1, -1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:-1:1, 1:-1:-1], (slice(-1, -1, 1), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1:-1:1, -1:1:-1], (slice(-1, -1, 1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1:-1:1, -1:-1:1], (slice(-1, -1, 1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1:-1:1, 1:1:-1], (slice(-1, -1, 1), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1:-1:1, 1:-1:1], (slice(-1, -1, 1), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1:-1:1, -1:1:1], (slice(-1, -1, 1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1:-1:1, 1:-1], (slice(-1, -1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:-1:1, 1:-1:], (slice(-1, -1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:-1:1, -1:1], (slice(-1, -1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:-1:1, -1:1:], (slice(-1, -1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:-1:1, 1::-1], (slice(-1, -1, 1), slice(1, None, -1)))
+        self.assertEqual(subscript[-1:-1:1, -1::1], (slice(-1, -1, 1), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1:-1:1, :1:-1], (slice(-1, -1, 1), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1:-1:1, :-1:1], (slice(-1, -1, 1), slice(None, -1, 1)))
+        self.assertEqual(subscript[1:1:-1, None], (slice(1, 1, -1), None))
+        self.assertEqual(subscript[1:1:-1 ,''], (slice(1, 1, -1), ''))
+        self.assertEqual(subscript[1:1:-1, 5], (slice(1, 1, -1), 5))
+        self.assertEqual(subscript[1:1:-1, :], (slice(1, 1, -1), slice(None, None, None)))
+        self.assertEqual(subscript[1:1:-1, 1:1:1], (slice(1, 1, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[1:1:-1, 1:1], (slice(1, 1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:1:-1, 1:1:], (slice(1, 1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:1:-1, 1::1], (slice(1, 1, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[1:1:-1, 1:], (slice(1, 1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[1:1:-1, 1::], (slice(1, 1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[1:1:-1, :1:1], (slice(1, 1, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[1:1:-1, :1], (slice(1, 1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:1:-1, :1:], (slice(1, 1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:1:-1, -1:-1:-1], (slice(1, 1, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1:1:-1, -1:-1], (slice(1, 1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:1:-1, -1:-1:], (slice(1, 1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:1:-1, -1::-1], (slice(1, 1, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[1:1:-1, -1:], (slice(1, 1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:1:-1, -1::], (slice(1, 1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:1:-1, :-1:-1], (slice(1, 1, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[1:1:-1, :-1], (slice(1, 1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:1:-1, :-1:], (slice(1, 1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:1:-1, 1:-1:-1], (slice(1, 1, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[1:1:-1, -1:1:-1], (slice(1, 1, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1:1:-1, -1:-1:1], (slice(1, 1, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1:1:-1, 1:1:-1], (slice(1, 1, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[1:1:-1, 1:-1:1], (slice(1, 1, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[1:1:-1, -1:1:1], (slice(1, 1, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1:1:-1, 1:-1], (slice(1, 1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:1:-1, 1:-1:], (slice(1, 1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:1:-1, -1:1], (slice(1, 1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:1:-1, -1:1:], (slice(1, 1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:1:-1, 1::-1], (slice(1, 1, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[1:1:-1, -1::1], (slice(1, 1, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[1:1:-1, :1:-1], (slice(1, 1, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[1:1:-1, :-1:1], (slice(1, 1, -1), slice(None, -1, 1)))
+        self.assertEqual(subscript[1:-1:1, None], (slice(1, -1, 1), None))
+        self.assertEqual(subscript[1:-1:1 ,''], (slice(1, -1, 1), ''))
+        self.assertEqual(subscript[1:-1:1, 5], (slice(1, -1, 1), 5))
+        self.assertEqual(subscript[1:-1:1, :], (slice(1, -1, 1), slice(None, None, None)))
+        self.assertEqual(subscript[1:-1:1, 1:1:1], (slice(1, -1, 1), slice(1, 1, 1)))
+        self.assertEqual(subscript[1:-1:1, 1:1], (slice(1, -1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:-1:1, 1:1:], (slice(1, -1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[1:-1:1, 1::1], (slice(1, -1, 1), slice(1, None, 1)))
+        self.assertEqual(subscript[1:-1:1, 1:], (slice(1, -1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[1:-1:1, 1::], (slice(1, -1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[1:-1:1, :1:1], (slice(1, -1, 1), slice(None, 1, 1)))
+        self.assertEqual(subscript[1:-1:1, :1], (slice(1, -1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:-1:1, :1:], (slice(1, -1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[1:-1:1, -1:-1:-1], (slice(1, -1, 1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1:-1:1, -1:-1], (slice(1, -1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:-1:1, -1:-1:], (slice(1, -1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:-1:1, -1::-1], (slice(1, -1, 1), slice(-1, None, -1)))
+        self.assertEqual(subscript[1:-1:1, -1:], (slice(1, -1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:-1:1, -1::], (slice(1, -1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[1:-1:1, :-1:-1], (slice(1, -1, 1), slice(None, -1, -1)))
+        self.assertEqual(subscript[1:-1:1, :-1], (slice(1, -1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:-1:1, :-1:], (slice(1, -1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[1:-1:1, 1:-1:-1], (slice(1, -1, 1), slice(1, -1, -1)))
+        self.assertEqual(subscript[1:-1:1, -1:1:-1], (slice(1, -1, 1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1:-1:1, -1:-1:1], (slice(1, -1, 1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1:-1:1, 1:1:-1], (slice(1, -1, 1), slice(1, 1, -1)))
+        self.assertEqual(subscript[1:-1:1, 1:-1:1], (slice(1, -1, 1), slice(1, -1, 1)))
+        self.assertEqual(subscript[1:-1:1, -1:1:1], (slice(1, -1, 1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1:-1:1, 1:-1], (slice(1, -1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:-1:1, 1:-1:], (slice(1, -1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[1:-1:1, -1:1], (slice(1, -1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:-1:1, -1:1:], (slice(1, -1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:-1:1, 1::-1], (slice(1, -1, 1), slice(1, None, -1)))
+        self.assertEqual(subscript[1:-1:1, -1::1], (slice(1, -1, 1), slice(-1, None, 1)))
+        self.assertEqual(subscript[1:-1:1, :1:-1], (slice(1, -1, 1), slice(None, 1, -1)))
+        self.assertEqual(subscript[1:-1:1, :-1:1], (slice(1, -1, 1), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1:1:1, None], (slice(-1, 1, 1), None))
+        self.assertEqual(subscript[-1:1:1 ,''], (slice(-1, 1, 1), ''))
+        self.assertEqual(subscript[-1:1:1, 5], (slice(-1, 1, 1), 5))
+        self.assertEqual(subscript[-1:1:1, :], (slice(-1, 1, 1), slice(None, None, None)))
+        self.assertEqual(subscript[-1:1:1, 1:1:1], (slice(-1, 1, 1), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1:1:1, 1:1], (slice(-1, 1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:1:1, 1:1:], (slice(-1, 1, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:1:1, 1::1], (slice(-1, 1, 1), slice(1, None, 1)))
+        self.assertEqual(subscript[-1:1:1, 1:], (slice(-1, 1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:1:1, 1::], (slice(-1, 1, 1), slice(1, None, None)))
+        self.assertEqual(subscript[-1:1:1, :1:1], (slice(-1, 1, 1), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1:1:1, :1], (slice(-1, 1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:1:1, :1:], (slice(-1, 1, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:1:1, -1:-1:-1], (slice(-1, 1, 1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1:1:1, -1:-1], (slice(-1, 1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:1:1, -1:-1:], (slice(-1, 1, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:1:1, -1::-1], (slice(-1, 1, 1), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1:1:1, -1:], (slice(-1, 1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:1:1, -1::], (slice(-1, 1, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:1:1, :-1:-1], (slice(-1, 1, 1), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1:1:1, :-1], (slice(-1, 1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:1:1, :-1:], (slice(-1, 1, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:1:1, 1:-1:-1], (slice(-1, 1, 1), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1:1:1, -1:1:-1], (slice(-1, 1, 1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1:1:1, -1:-1:1], (slice(-1, 1, 1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1:1:1, 1:1:-1], (slice(-1, 1, 1), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1:1:1, 1:-1:1], (slice(-1, 1, 1), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1:1:1, -1:1:1], (slice(-1, 1, 1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1:1:1, 1:-1], (slice(-1, 1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:1:1, 1:-1:], (slice(-1, 1, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:1:1, -1:1], (slice(-1, 1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:1:1, -1:1:], (slice(-1, 1, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:1:1, 1::-1], (slice(-1, 1, 1), slice(1, None, -1)))
+        self.assertEqual(subscript[-1:1:1, -1::1], (slice(-1, 1, 1), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1:1:1, :1:-1], (slice(-1, 1, 1), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1:1:1, :-1:1], (slice(-1, 1, 1), slice(None, -1, 1)))
+        self.assertEqual(subscript[1:-1, None], (slice(1, -1, None), None))
+        self.assertEqual(subscript[1:-1 ,''], (slice(1, -1, None), ''))
+        self.assertEqual(subscript[1:-1, 5], (slice(1, -1, None), 5))
+        self.assertEqual(subscript[1:-1, :], (slice(1, -1, None), slice(None, None, None)))
+        self.assertEqual(subscript[1:-1, 1:1:1], (slice(1, -1, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[1:-1, 1:1], (slice(1, -1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[1:-1, 1:1:], (slice(1, -1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[1:-1, 1::1], (slice(1, -1, None), slice(1, None, 1)))
+        self.assertEqual(subscript[1:-1, 1:], (slice(1, -1, None), slice(1, None, None)))
+        self.assertEqual(subscript[1:-1, 1::], (slice(1, -1, None), slice(1, None, None)))
+        self.assertEqual(subscript[1:-1, :1:1], (slice(1, -1, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[1:-1, :1], (slice(1, -1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[1:-1, :1:], (slice(1, -1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[1:-1, -1:-1:-1], (slice(1, -1, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1:-1, -1:-1], (slice(1, -1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:-1, -1:-1:], (slice(1, -1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[1:-1, -1::-1], (slice(1, -1, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[1:-1, -1:], (slice(1, -1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[1:-1, -1::], (slice(1, -1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[1:-1, :-1:-1], (slice(1, -1, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[1:-1, :-1], (slice(1, -1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[1:-1, :-1:], (slice(1, -1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[1:-1, 1:-1:-1], (slice(1, -1, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[1:-1, -1:1:-1], (slice(1, -1, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1:-1, -1:-1:1], (slice(1, -1, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1:-1, 1:1:-1], (slice(1, -1, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[1:-1, 1:-1:1], (slice(1, -1, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[1:-1, -1:1:1], (slice(1, -1, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1:-1, 1:-1], (slice(1, -1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[1:-1, 1:-1:], (slice(1, -1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[1:-1, -1:1], (slice(1, -1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:-1, -1:1:], (slice(1, -1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[1:-1, 1::-1], (slice(1, -1, None), slice(1, None, -1)))
+        self.assertEqual(subscript[1:-1, -1::1], (slice(1, -1, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[1:-1, :1:-1], (slice(1, -1, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[1:-1, :-1:1], (slice(1, -1, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1:1, None], (slice(-1, 1, None), None))
+        self.assertEqual(subscript[-1:1 ,''], (slice(-1, 1, None), ''))
+        self.assertEqual(subscript[-1:1, 5], (slice(-1, 1, None), 5))
+        self.assertEqual(subscript[-1:1, :], (slice(-1, 1, None), slice(None, None, None)))
+        self.assertEqual(subscript[-1:1, 1:1:1], (slice(-1, 1, None), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1:1, 1:1], (slice(-1, 1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:1, 1:1:], (slice(-1, 1, None), slice(1, 1, None)))
+        self.assertEqual(subscript[-1:1, 1::1], (slice(-1, 1, None), slice(1, None, 1)))
+        self.assertEqual(subscript[-1:1, 1:], (slice(-1, 1, None), slice(1, None, None)))
+        self.assertEqual(subscript[-1:1, 1::], (slice(-1, 1, None), slice(1, None, None)))
+        self.assertEqual(subscript[-1:1, :1:1], (slice(-1, 1, None), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1:1, :1], (slice(-1, 1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:1, :1:], (slice(-1, 1, None), slice(None, 1, None)))
+        self.assertEqual(subscript[-1:1, -1:-1:-1], (slice(-1, 1, None), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1:1, -1:-1], (slice(-1, 1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:1, -1:-1:], (slice(-1, 1, None), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1:1, -1::-1], (slice(-1, 1, None), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1:1, -1:], (slice(-1, 1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:1, -1::], (slice(-1, 1, None), slice(-1, None, None)))
+        self.assertEqual(subscript[-1:1, :-1:-1], (slice(-1, 1, None), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1:1, :-1], (slice(-1, 1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:1, :-1:], (slice(-1, 1, None), slice(None, -1, None)))
+        self.assertEqual(subscript[-1:1, 1:-1:-1], (slice(-1, 1, None), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1:1, -1:1:-1], (slice(-1, 1, None), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1:1, -1:-1:1], (slice(-1, 1, None), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1:1, 1:1:-1], (slice(-1, 1, None), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1:1, 1:-1:1], (slice(-1, 1, None), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1:1, -1:1:1], (slice(-1, 1, None), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1:1, 1:-1], (slice(-1, 1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:1, 1:-1:], (slice(-1, 1, None), slice(1, -1, None)))
+        self.assertEqual(subscript[-1:1, -1:1], (slice(-1, 1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:1, -1:1:], (slice(-1, 1, None), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1:1, 1::-1], (slice(-1, 1, None), slice(1, None, -1)))
+        self.assertEqual(subscript[-1:1, -1::1], (slice(-1, 1, None), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1:1, :1:-1], (slice(-1, 1, None), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1:1, :-1:1], (slice(-1, 1, None), slice(None, -1, 1)))
+        self.assertEqual(subscript[1::-1, None], (slice(1, None, -1), None))
+        self.assertEqual(subscript[1::-1 ,''], (slice(1, None, -1), ''))
+        self.assertEqual(subscript[1::-1, 5], (slice(1, None, -1), 5))
+        self.assertEqual(subscript[1::-1, :], (slice(1, None, -1), slice(None, None, None)))
+        self.assertEqual(subscript[1::-1, 1:1:1], (slice(1, None, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[1::-1, 1:1], (slice(1, None, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[1::-1, 1:1:], (slice(1, None, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[1::-1, 1::1], (slice(1, None, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[1::-1, 1:], (slice(1, None, -1), slice(1, None, None)))
+        self.assertEqual(subscript[1::-1, 1::], (slice(1, None, -1), slice(1, None, None)))
+        self.assertEqual(subscript[1::-1, :1:1], (slice(1, None, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[1::-1, :1], (slice(1, None, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[1::-1, :1:], (slice(1, None, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[1::-1, -1:-1:-1], (slice(1, None, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[1::-1, -1:-1], (slice(1, None, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1::-1, -1:-1:], (slice(1, None, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[1::-1, -1::-1], (slice(1, None, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[1::-1, -1:], (slice(1, None, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[1::-1, -1::], (slice(1, None, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[1::-1, :-1:-1], (slice(1, None, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[1::-1, :-1], (slice(1, None, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[1::-1, :-1:], (slice(1, None, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[1::-1, 1:-1:-1], (slice(1, None, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[1::-1, -1:1:-1], (slice(1, None, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[1::-1, -1:-1:1], (slice(1, None, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[1::-1, 1:1:-1], (slice(1, None, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[1::-1, 1:-1:1], (slice(1, None, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[1::-1, -1:1:1], (slice(1, None, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[1::-1, 1:-1], (slice(1, None, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[1::-1, 1:-1:], (slice(1, None, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[1::-1, -1:1], (slice(1, None, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1::-1, -1:1:], (slice(1, None, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[1::-1, 1::-1], (slice(1, None, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[1::-1, -1::1], (slice(1, None, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[1::-1, :1:-1], (slice(1, None, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[1::-1, :-1:1], (slice(1, None, -1), slice(None, -1, 1)))
+        self.assertEqual(subscript[-1::1, None], (slice(-1, None, 1), None))
+        self.assertEqual(subscript[-1::1 ,''], (slice(-1, None, 1), ''))
+        self.assertEqual(subscript[-1::1, 5], (slice(-1, None, 1), 5))
+        self.assertEqual(subscript[-1::1, :], (slice(-1, None, 1), slice(None, None, None)))
+        self.assertEqual(subscript[-1::1, 1:1:1], (slice(-1, None, 1), slice(1, 1, 1)))
+        self.assertEqual(subscript[-1::1, 1:1], (slice(-1, None, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1::1, 1:1:], (slice(-1, None, 1), slice(1, 1, None)))
+        self.assertEqual(subscript[-1::1, 1::1], (slice(-1, None, 1), slice(1, None, 1)))
+        self.assertEqual(subscript[-1::1, 1:], (slice(-1, None, 1), slice(1, None, None)))
+        self.assertEqual(subscript[-1::1, 1::], (slice(-1, None, 1), slice(1, None, None)))
+        self.assertEqual(subscript[-1::1, :1:1], (slice(-1, None, 1), slice(None, 1, 1)))
+        self.assertEqual(subscript[-1::1, :1], (slice(-1, None, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1::1, :1:], (slice(-1, None, 1), slice(None, 1, None)))
+        self.assertEqual(subscript[-1::1, -1:-1:-1], (slice(-1, None, 1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[-1::1, -1:-1], (slice(-1, None, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1::1, -1:-1:], (slice(-1, None, 1), slice(-1, -1, None)))
+        self.assertEqual(subscript[-1::1, -1::-1], (slice(-1, None, 1), slice(-1, None, -1)))
+        self.assertEqual(subscript[-1::1, -1:], (slice(-1, None, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1::1, -1::], (slice(-1, None, 1), slice(-1, None, None)))
+        self.assertEqual(subscript[-1::1, :-1:-1], (slice(-1, None, 1), slice(None, -1, -1)))
+        self.assertEqual(subscript[-1::1, :-1], (slice(-1, None, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1::1, :-1:], (slice(-1, None, 1), slice(None, -1, None)))
+        self.assertEqual(subscript[-1::1, 1:-1:-1], (slice(-1, None, 1), slice(1, -1, -1)))
+        self.assertEqual(subscript[-1::1, -1:1:-1], (slice(-1, None, 1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[-1::1, -1:-1:1], (slice(-1, None, 1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[-1::1, 1:1:-1], (slice(-1, None, 1), slice(1, 1, -1)))
+        self.assertEqual(subscript[-1::1, 1:-1:1], (slice(-1, None, 1), slice(1, -1, 1)))
+        self.assertEqual(subscript[-1::1, -1:1:1], (slice(-1, None, 1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[-1::1, 1:-1], (slice(-1, None, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1::1, 1:-1:], (slice(-1, None, 1), slice(1, -1, None)))
+        self.assertEqual(subscript[-1::1, -1:1], (slice(-1, None, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1::1, -1:1:], (slice(-1, None, 1), slice(-1, 1, None)))
+        self.assertEqual(subscript[-1::1, 1::-1], (slice(-1, None, 1), slice(1, None, -1)))
+        self.assertEqual(subscript[-1::1, -1::1], (slice(-1, None, 1), slice(-1, None, 1)))
+        self.assertEqual(subscript[-1::1, :1:-1], (slice(-1, None, 1), slice(None, 1, -1)))
+        self.assertEqual(subscript[-1::1, :-1:1], (slice(-1, None, 1), slice(None, -1, 1)))
+        self.assertEqual(subscript[:1:-1, None], (slice(None, 1, -1), None))
+        self.assertEqual(subscript[:1:-1 ,''], (slice(None, 1, -1), ''))
+        self.assertEqual(subscript[:1:-1, 5], (slice(None, 1, -1), 5))
+        self.assertEqual(subscript[:1:-1, :], (slice(None, 1, -1), slice(None, None, None)))
+        self.assertEqual(subscript[:1:-1, 1:1:1], (slice(None, 1, -1), slice(1, 1, 1)))
+        self.assertEqual(subscript[:1:-1, 1:1], (slice(None, 1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[:1:-1, 1:1:], (slice(None, 1, -1), slice(1, 1, None)))
+        self.assertEqual(subscript[:1:-1, 1::1], (slice(None, 1, -1), slice(1, None, 1)))
+        self.assertEqual(subscript[:1:-1, 1:], (slice(None, 1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[:1:-1, 1::], (slice(None, 1, -1), slice(1, None, None)))
+        self.assertEqual(subscript[:1:-1, :1:1], (slice(None, 1, -1), slice(None, 1, 1)))
+        self.assertEqual(subscript[:1:-1, :1], (slice(None, 1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[:1:-1, :1:], (slice(None, 1, -1), slice(None, 1, None)))
+        self.assertEqual(subscript[:1:-1, -1:-1:-1], (slice(None, 1, -1), slice(-1, -1, -1)))
+        self.assertEqual(subscript[:1:-1, -1:-1], (slice(None, 1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[:1:-1, -1:-1:], (slice(None, 1, -1), slice(-1, -1, None)))
+        self.assertEqual(subscript[:1:-1, -1::-1], (slice(None, 1, -1), slice(-1, None, -1)))
+        self.assertEqual(subscript[:1:-1, -1:], (slice(None, 1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[:1:-1, -1::], (slice(None, 1, -1), slice(-1, None, None)))
+        self.assertEqual(subscript[:1:-1, :-1:-1], (slice(None, 1, -1), slice(None, -1, -1)))
+        self.assertEqual(subscript[:1:-1, :-1], (slice(None, 1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[:1:-1, :-1:], (slice(None, 1, -1), slice(None, -1, None)))
+        self.assertEqual(subscript[:1:-1, 1:-1:-1], (slice(None, 1, -1), slice(1, -1, -1)))
+        self.assertEqual(subscript[:1:-1, -1:1:-1], (slice(None, 1, -1), slice(-1, 1, -1)))
+        self.assertEqual(subscript[:1:-1, -1:-1:1], (slice(None, 1, -1), slice(-1, -1, 1)))
+        self.assertEqual(subscript[:1:-1, 1:1:-1], (slice(None, 1, -1), slice(1, 1, -1)))
+        self.assertEqual(subscript[:1:-1, 1:-1:1], (slice(None, 1, -1), slice(1, -1, 1)))
+        self.assertEqual(subscript[:1:-1, -1:1:1], (slice(None, 1, -1), slice(-1, 1, 1)))
+        self.assertEqual(subscript[:1:-1, 1:-1], (slice(None, 1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[:1:-1, 1:-1:], (slice(None, 1, -1), slice(1, -1, None)))
+        self.assertEqual(subscript[:1:-1, -1:1], (slice(None, 1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[:1:-1, -1:1:], (slice(None, 1, -1), slice(-1, 1, None)))
+        self.assertEqual(subscript[:1:-1, 1::-1], (slice(None, 1, -1), slice(1, None, -1)))
+        self.assertEqual(subscript[:1:-1, -1::1], (slice(None, 1, -1), slice(-1, None, 1)))
+        self.assertEqual(subscript[:1:-1, :1:-1], (slice(None, 1, -1), slice(None, 1, -1)))
+        self.assertEqual(subscript[:1:-1, :-1:1], (slice(None, 1, -1), slice(None, -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()