INLINE_STREAM -> INLINE_FUSED
[darcs-mirrors/vector.git] / internal / unbox-tuple-instances
index 48917ec..a9e6501 100644 (file)
+#ifdef DEFINE_INSTANCES
 data instance MVector s (a, b)
-    = MV_2 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
+    = MV_2 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
 data instance Vector (a, b)
-    = V_2 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
+    = V_2 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
 instance (Unbox a, Unbox b) => Unbox (a, b)
 instance (Unbox a, Unbox b) => M.MVector MVector (a, b) where
-  {-# INLINE length  #-}
-  length (MV_2 n_ as bs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_2 n_ as bs) i_ m_
-      = MV_2 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_2 n_ as bs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice i_ m_ (MV_2 n_ as bs)
+      = MV_2 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
           return $ MV_2 n_ as bs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b)
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b)
       = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
           return $ MV_2 n_ as bs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_2 n_ as bs) i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_2 n_ as bs) i_
       = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
           return (a, b)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_2 n_ as bs) i_ (a, b)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-  {-# INLINE clear  #-}
-  clear (MV_2 n_ as bs)
-      = do
-          M.clear as
-          M.clear bs
-  {-# INLINE set  #-}
-  set (MV_2 n_ as bs) (a, b)
-      = do
-          M.set as a
-          M.set bs b
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_2 n_ as bs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          return $ MV_2 (m_+n_) as bs
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_2 n_ as bs) i_ (a, b)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+  {-# INLINE basicClear  #-}
+  basicClear (MV_2 n_ as bs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_2 n_ as bs) (a, b)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_2 n_1 as1 bs1) (MV_2 n_2 as2 bs2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_2 n_ as bs) m_
+      = do
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          return $ MV_2 (m_+n_) as' bs'
 instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_2 n_ as bs)
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_2 n_ as bs)
       = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
           return $ V_2 n_ as' bs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_2 n_ as bs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          return $ MV_2 n_ as' bs'
   {-# INLINE basicLength  #-}
   basicLength (V_2 n_ as bs) = n_
   {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_2 n_ as bs) i_ m_
-      = V_2 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
+  basicUnsafeSlice i_ m_ (V_2 n_ as bs)
+      = V_2 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_2 n_ as bs) i_
       = do
           a <- G.basicUnsafeIndexM as i_
           b <- G.basicUnsafeIndexM bs i_
           return (a, b)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_2 n_1 as1 bs1) (V_2 n_2 as2 bs2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+#endif
+#ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 2 vectors
+zip :: (Unbox a, Unbox b) => MVector s a ->
+                             MVector s b -> MVector s (a, b)
+{-# INLINE_FUSED zip #-}
+zip as bs = MV_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
+  where len = length as `delayed_min` length bs
+-- | /O(1)/ Unzip 2 vectors
+unzip :: (Unbox a, Unbox b) => MVector s (a, b) -> (MVector s a,
+                                                    MVector s b)
+{-# INLINE unzip #-}
+unzip (MV_2 n_ as bs) = (as, bs)
+#endif
+#ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 2 vectors
+zip :: (Unbox a, Unbox b) => Vector a -> Vector b -> Vector (a, b)
+{-# INLINE_FUSED zip #-}
+zip as bs = V_2 len (unsafeSlice 0 len as) (unsafeSlice 0 len bs)
+  where len = length as `delayed_min` length bs
+{-# RULES "stream/zip [Vector.Unboxed]" forall as bs .
+  G.stream (zip as bs) = Stream.zipWith (,) (G.stream as)
+                                            (G.stream bs)
+  #-}
+-- | /O(1)/ Unzip 2 vectors
+unzip :: (Unbox a, Unbox b) => Vector (a, b) -> (Vector a,
+                                                 Vector b)
+{-# INLINE unzip #-}
+unzip (V_2 n_ as bs) = (as, bs)
+#endif
+#ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c)
-    = MV_3 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
+    = MV_3 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
 data instance Vector (a, b, c)
-    = V_3 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
+    = V_3 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
 instance (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c)
 instance (Unbox a,
           Unbox b,
           Unbox c) => M.MVector MVector (a, b, c) where
-  {-# INLINE length  #-}
-  length (MV_3 n_ as bs cs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_3 n_ as bs cs) i_ m_
-      = MV_3 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_3 n_ as bs cs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice i_ m_ (MV_3 n_ as bs cs)
+      = MV_3 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
           return $ MV_3 n_ as bs cs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c)
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c)
       = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
           return $ MV_3 n_ as bs cs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_3 n_ as bs cs) i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_3 n_ as bs cs) i_
       = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
           return (a, b, c)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-  {-# INLINE clear  #-}
-  clear (MV_3 n_ as bs cs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-  {-# INLINE set  #-}
-  set (MV_3 n_ as bs cs) (a, b, c)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_3 n_ as bs cs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          return $ MV_3 (m_+n_) as bs cs
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_3 n_ as bs cs) i_ (a, b, c)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+  {-# INLINE basicClear  #-}
+  basicClear (MV_3 n_ as bs cs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_3 n_ as bs cs) (a, b, c)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_3 n_1 as1 bs1 cs1) (MV_3 n_2 as2 bs2 cs2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove cs1 cs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_3 n_ as bs cs) m_
+      = do
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          return $ MV_3 (m_+n_) as' bs' cs'
 instance (Unbox a,
           Unbox b,
           Unbox c) => G.Vector Vector (a, b, c) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_3 n_ as bs cs)
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_3 n_ as bs cs)
       = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
           return $ V_3 n_ as' bs' cs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_3 n_ as bs cs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          return $ MV_3 n_ as' bs' cs'
   {-# INLINE basicLength  #-}
   basicLength (V_3 n_ as bs cs) = n_
   {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_3 n_ as bs cs) i_ m_
-      = V_3 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
+  basicUnsafeSlice i_ m_ (V_3 n_ as bs cs)
+      = V_3 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_3 n_ as bs cs) i_
       = do
@@ -179,115 +244,192 @@ instance (Unbox a,
           b <- G.basicUnsafeIndexM bs i_
           c <- G.basicUnsafeIndexM cs i_
           return (a, b, c)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_3 n_1 as1 bs1 cs1) (V_3 n_2 as2 bs2 cs2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
+#endif
+#ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 3 vectors
+zip3 :: (Unbox a, Unbox b, Unbox c) => MVector s a ->
+                                       MVector s b ->
+                                       MVector s c -> MVector s (a, b, c)
+{-# INLINE_FUSED zip3 #-}
+zip3 as bs cs = MV_3 len (unsafeSlice 0 len as)
+                         (unsafeSlice 0 len bs)
+                         (unsafeSlice 0 len cs)
+  where
+    len = length as `delayed_min` length bs `delayed_min` length cs
+-- | /O(1)/ Unzip 3 vectors
+unzip3 :: (Unbox a,
+           Unbox b,
+           Unbox c) => MVector s (a, b, c) -> (MVector s a,
+                                               MVector s b,
+                                               MVector s c)
+{-# INLINE unzip3 #-}
+unzip3 (MV_3 n_ as bs cs) = (as, bs, cs)
+#endif
+#ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 3 vectors
+zip3 :: (Unbox a, Unbox b, Unbox c) => Vector a ->
+                                       Vector b ->
+                                       Vector c -> Vector (a, b, c)
+{-# INLINE_FUSED zip3 #-}
+zip3 as bs cs = V_3 len (unsafeSlice 0 len as)
+                        (unsafeSlice 0 len bs)
+                        (unsafeSlice 0 len cs)
+  where
+    len = length as `delayed_min` length bs `delayed_min` length cs
+{-# RULES "stream/zip3 [Vector.Unboxed]" forall as bs cs .
+  G.stream (zip3 as bs cs) = Stream.zipWith3 (, ,) (G.stream as)
+                                                   (G.stream bs)
+                                                   (G.stream cs)
+  #-}
+-- | /O(1)/ Unzip 3 vectors
+unzip3 :: (Unbox a,
+           Unbox b,
+           Unbox c) => Vector (a, b, c) -> (Vector a, Vector b, Vector c)
+{-# INLINE unzip3 #-}
+unzip3 (V_3 n_ as bs cs) = (as, bs, cs)
+#endif
+#ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c, d)
-    = MV_4 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
+    = MV_4 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
+                               !(MVector s d)
 data instance Vector (a, b, c, d)
-    = V_4 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
+    = V_4 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
+                              !(Vector d)
 instance (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d)
 instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d) => M.MVector MVector (a, b, c, d) where
-  {-# INLINE length  #-}
-  length (MV_4 n_ as bs cs ds) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_4 n_ as bs cs ds) i_ m_
-      = MV_4 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_4 n_ as bs cs ds) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice i_ m_ (MV_4 n_ as bs cs ds)
+      = MV_4 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
+                (M.basicUnsafeSlice i_ m_ ds)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
           return $ MV_4 n_ as bs cs ds
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d)
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c, d)
       = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
+          ds <- M.basicUnsafeReplicate n_ d
           return $ MV_4 n_ as bs cs ds
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_4 n_ as bs cs ds) i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_4 n_ as bs cs ds) i_
       = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
           return (a, b, c, d)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-  {-# INLINE clear  #-}
-  clear (MV_4 n_ as bs cs ds)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-  {-# INLINE set  #-}
-  set (MV_4 n_ as bs cs ds) (a, b, c, d)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2 bs2 cs2 ds2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_4 n_ as bs cs ds) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          return $ MV_4 (m_+n_) as bs cs ds
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_4 n_ as bs cs ds) i_ (a, b, c, d)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+  {-# INLINE basicClear  #-}
+  basicClear (MV_4 n_ as bs cs ds)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+  {-# INLINE basicSet  #-}
+  basicSet (MV_4 n_ as bs cs ds) (a, b, c, d)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
+                                                       bs2
+                                                       cs2
+                                                       ds2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_4 n_1 as1 bs1 cs1 ds1) (MV_4 n_2 as2
+                                                       bs2
+                                                       cs2
+                                                       ds2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove cs1 cs2
+          M.basicUnsafeMove ds1 ds2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_4 n_ as bs cs ds) m_
+      = do
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          ds' <- M.basicUnsafeGrow ds m_
+          return $ MV_4 (m_+n_) as' bs' cs' ds'
 instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d) => G.Vector Vector (a, b, c, d) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_4 n_ as bs cs ds)
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_4 n_ as bs cs ds)
       = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
+          ds' <- G.basicUnsafeFreeze ds
           return $ V_4 n_ as' bs' cs' ds'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_4 n_ as bs cs ds)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          return $ MV_4 n_ as' bs' cs' ds'
   {-# INLINE basicLength  #-}
   basicLength (V_4 n_ as bs cs ds) = n_
   {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_4 n_ as bs cs ds) i_ m_
-      = V_4 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
+  basicUnsafeSlice i_ m_ (V_4 n_ as bs cs ds)
+      = V_4 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
+               (G.basicUnsafeSlice i_ m_ ds)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
       = do
@@ -296,18 +438,96 @@ instance (Unbox a,
           c <- G.basicUnsafeIndexM cs i_
           d <- G.basicUnsafeIndexM ds i_
           return (a, b, c, d)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_4 n_1 as1 bs1 cs1 ds1) (V_4 n_2 as2
+                                                      bs2
+                                                      cs2
+                                                      ds2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+          G.basicUnsafeCopy ds1 ds2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c, d)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
+        . G.elemseq (undefined :: Vector d) d
+#endif
+#ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 4 vectors
+zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => MVector s a ->
+                                                MVector s b ->
+                                                MVector s c ->
+                                                MVector s d -> MVector s (a, b, c, d)
+{-# INLINE_FUSED zip4 #-}
+zip4 as bs cs ds = MV_4 len (unsafeSlice 0 len as)
+                            (unsafeSlice 0 len bs)
+                            (unsafeSlice 0 len cs)
+                            (unsafeSlice 0 len ds)
+  where
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds
+-- | /O(1)/ Unzip 4 vectors
+unzip4 :: (Unbox a,
+           Unbox b,
+           Unbox c,
+           Unbox d) => MVector s (a, b, c, d) -> (MVector s a,
+                                                  MVector s b,
+                                                  MVector s c,
+                                                  MVector s d)
+{-# INLINE unzip4 #-}
+unzip4 (MV_4 n_ as bs cs ds) = (as, bs, cs, ds)
+#endif
+#ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 4 vectors
+zip4 :: (Unbox a, Unbox b, Unbox c, Unbox d) => Vector a ->
+                                                Vector b ->
+                                                Vector c ->
+                                                Vector d -> Vector (a, b, c, d)
+{-# INLINE_FUSED zip4 #-}
+zip4 as bs cs ds = V_4 len (unsafeSlice 0 len as)
+                           (unsafeSlice 0 len bs)
+                           (unsafeSlice 0 len cs)
+                           (unsafeSlice 0 len ds)
+  where
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds
+{-# RULES "stream/zip4 [Vector.Unboxed]" forall as bs cs ds .
+  G.stream (zip4 as bs cs ds) = Stream.zipWith4 (, , ,) (G.stream as)
+                                                        (G.stream bs)
+                                                        (G.stream cs)
+                                                        (G.stream ds)
+  #-}
+-- | /O(1)/ Unzip 4 vectors
+unzip4 :: (Unbox a,
+           Unbox b,
+           Unbox c,
+           Unbox d) => Vector (a, b, c, d) -> (Vector a,
+                                               Vector b,
+                                               Vector c,
+                                               Vector d)
+{-# INLINE unzip4 #-}
+unzip4 (V_4 n_ as bs cs ds) = (as, bs, cs, ds)
+#endif
+#ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c, d, e)
-    = MV_5 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
-                               (MVector s e)
+    = MV_5 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
+                               !(MVector s d)
+                               !(MVector s e)
 data instance Vector (a, b, c, d, e)
-    = V_5 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
-                              (Vector e)
+    = V_5 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
+                              !(Vector d)
+                              !(Vector e)
 instance (Unbox a,
           Unbox b,
           Unbox c,
@@ -318,121 +538,142 @@ instance (Unbox a,
           Unbox c,
           Unbox d,
           Unbox e) => M.MVector MVector (a, b, c, d, e) where
-  {-# INLINE length  #-}
-  length (MV_5 n_ as bs cs ds es) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_5 n_ as bs cs ds es) i_ m_
-      = MV_5 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
-                                                    bs2
-                                                    cs2
-                                                    ds2
-                                                    es2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_5 n_ as bs cs ds es) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice i_ m_ (MV_5 n_ as bs cs ds es)
+      = MV_5 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
+                (M.basicUnsafeSlice i_ m_ ds)
+                (M.basicUnsafeSlice i_ m_ es)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
+                                                         bs2
+                                                         cs2
+                                                         ds2
+                                                         es2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
           return $ MV_5 n_ as bs cs ds es
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c, d, e)
+      = do
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
+          ds <- M.basicUnsafeReplicate n_ d
+          es <- M.basicUnsafeReplicate n_ e
           return $ MV_5 n_ as bs cs ds es
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_5 n_ as bs cs ds es) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_5 n_ as bs cs ds es) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
           return (a, b, c, d, e)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-  {-# INLINE clear  #-}
-  clear (MV_5 n_ as bs cs ds es)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-  {-# INLINE set  #-}
-  set (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
-                                                      bs2
-                                                      cs2
-                                                      ds2
-                                                      es2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_5 n_ as bs cs ds es) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          return $ MV_5 (m_+n_) as bs cs ds es
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_5 n_ as bs cs ds es) i_ (a, b, c, d, e)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+  {-# INLINE basicClear  #-}
+  basicClear (MV_5 n_ as bs cs ds es)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+  {-# INLINE basicSet  #-}
+  basicSet (MV_5 n_ as bs cs ds es) (a, b, c, d, e)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
+                                                           bs2
+                                                           cs2
+                                                           ds2
+                                                           es2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_5 n_1 as1 bs1 cs1 ds1 es1) (MV_5 n_2 as2
+                                                           bs2
+                                                           cs2
+                                                           ds2
+                                                           es2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove cs1 cs2
+          M.basicUnsafeMove ds1 ds2
+          M.basicUnsafeMove es1 es2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_5 n_ as bs cs ds es) m_
+      = do
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          ds' <- M.basicUnsafeGrow ds m_
+          es' <- M.basicUnsafeGrow es m_
+          return $ MV_5 (m_+n_) as' bs' cs' ds' es'
 instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d,
           Unbox e) => G.Vector Vector (a, b, c, d, e) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_5 n_ as bs cs ds es)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_5 n_ as bs cs ds es)
+      = do
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
+          ds' <- G.basicUnsafeFreeze ds
+          es' <- G.basicUnsafeFreeze es
           return $ V_5 n_ as' bs' cs' ds' es'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_5 n_ as bs cs ds es)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          es' <- G.basicUnsafeThaw es
+          return $ MV_5 n_ as' bs' cs' ds' es'
   {-# INLINE basicLength  #-}
   basicLength (V_5 n_ as bs cs ds es) = n_
   {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_5 n_ as bs cs ds es) i_ m_
-      = V_5 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
+  basicUnsafeSlice i_ m_ (V_5 n_ as bs cs ds es)
+      = V_5 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
+               (G.basicUnsafeSlice i_ m_ ds)
+               (G.basicUnsafeSlice i_ m_ es)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_5 n_ as bs cs ds es) i_
       = do
@@ -442,20 +683,124 @@ instance (Unbox a,
           d <- G.basicUnsafeIndexM ds i_
           e <- G.basicUnsafeIndexM es i_
           return (a, b, c, d, e)
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_5 n_1 as1 bs1 cs1 ds1 es1) (V_5 n_2 as2
+                                                          bs2
+                                                          cs2
+                                                          ds2
+                                                          es2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+          G.basicUnsafeCopy ds1 ds2
+          G.basicUnsafeCopy es1 es2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c, d, e)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
+        . G.elemseq (undefined :: Vector d) d
+        . G.elemseq (undefined :: Vector e) e
+#endif
+#ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 5 vectors
+zip5 :: (Unbox a,
+         Unbox b,
+         Unbox c,
+         Unbox d,
+         Unbox e) => MVector s a ->
+                     MVector s b ->
+                     MVector s c ->
+                     MVector s d ->
+                     MVector s e -> MVector s (a, b, c, d, e)
+{-# INLINE_FUSED zip5 #-}
+zip5 as bs cs ds es = MV_5 len (unsafeSlice 0 len as)
+                               (unsafeSlice 0 len bs)
+                               (unsafeSlice 0 len cs)
+                               (unsafeSlice 0 len ds)
+                               (unsafeSlice 0 len es)
+  where
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
+          length es
+-- | /O(1)/ Unzip 5 vectors
+unzip5 :: (Unbox a,
+           Unbox b,
+           Unbox c,
+           Unbox d,
+           Unbox e) => MVector s (a, b, c, d, e) -> (MVector s a,
+                                                     MVector s b,
+                                                     MVector s c,
+                                                     MVector s d,
+                                                     MVector s e)
+{-# INLINE unzip5 #-}
+unzip5 (MV_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
+#endif
+#ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 5 vectors
+zip5 :: (Unbox a,
+         Unbox b,
+         Unbox c,
+         Unbox d,
+         Unbox e) => Vector a ->
+                     Vector b ->
+                     Vector c ->
+                     Vector d ->
+                     Vector e -> Vector (a, b, c, d, e)
+{-# INLINE_FUSED zip5 #-}
+zip5 as bs cs ds es = V_5 len (unsafeSlice 0 len as)
+                              (unsafeSlice 0 len bs)
+                              (unsafeSlice 0 len cs)
+                              (unsafeSlice 0 len ds)
+                              (unsafeSlice 0 len es)
+  where
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
+          length es
+{-# RULES "stream/zip5 [Vector.Unboxed]" forall as bs cs ds es .
+  G.stream (zip5 as
+                 bs
+                 cs
+                 ds
+                 es) = Stream.zipWith5 (, , , ,) (G.stream as)
+                                                 (G.stream bs)
+                                                 (G.stream cs)
+                                                 (G.stream ds)
+                                                 (G.stream es)
+  #-}
+-- | /O(1)/ Unzip 5 vectors
+unzip5 :: (Unbox a,
+           Unbox b,
+           Unbox c,
+           Unbox d,
+           Unbox e) => Vector (a, b, c, d, e) -> (Vector a,
+                                                  Vector b,
+                                                  Vector c,
+                                                  Vector d,
+                                                  Vector e)
+{-# INLINE unzip5 #-}
+unzip5 (V_5 n_ as bs cs ds es) = (as, bs, cs, ds, es)
+#endif
+#ifdef DEFINE_INSTANCES
 data instance MVector s (a, b, c, d, e, f)
-    = MV_6 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
-                               (MVector s e)
-                               (MVector s f)
+    = MV_6 {-# UNPACK #-} !Int !(MVector s a)
+                               !(MVector s b)
+                               !(MVector s c)
+                               !(MVector s d)
+                               !(MVector s e)
+                               !(MVector s f)
 data instance Vector (a, b, c, d, e, f)
-    = V_6 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
-                              (Vector e)
-                              (Vector f)
+    = V_6 {-# UNPACK #-} !Int !(Vector a)
+                              !(Vector b)
+                              !(Vector c)
+                              !(Vector d)
+                              !(Vector e)
+                              !(Vector f)
 instance (Unbox a,
           Unbox b,
           Unbox c,
@@ -468,136 +813,160 @@ instance (Unbox a,
           Unbox d,
           Unbox e,
           Unbox f) => M.MVector MVector (a, b, c, d, e, f) where
-  {-# INLINE length  #-}
-  length (MV_6 n_ as bs cs ds es fs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_6 n_ as bs cs ds es fs) i_ m_
-      = MV_6 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
-                                                        bs2
-                                                        cs2
-                                                        ds2
-                                                        es2
-                                                        fs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
+  {-# INLINE basicLength  #-}
+  basicLength (MV_6 n_ as bs cs ds es fs) = n_
+  {-# INLINE basicUnsafeSlice  #-}
+  basicUnsafeSlice i_ m_ (MV_6 n_ as bs cs ds es fs)
+      = MV_6 m_ (M.basicUnsafeSlice i_ m_ as)
+                (M.basicUnsafeSlice i_ m_ bs)
+                (M.basicUnsafeSlice i_ m_ cs)
+                (M.basicUnsafeSlice i_ m_ ds)
+                (M.basicUnsafeSlice i_ m_ es)
+                (M.basicUnsafeSlice i_ m_ fs)
+  {-# INLINE basicOverlaps  #-}
+  basicOverlaps (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
+                                                             bs2
+                                                             cs2
+                                                             ds2
+                                                             es2
+                                                             fs2)
+      = M.basicOverlaps as1 as2
+        || M.basicOverlaps bs1 bs2
+        || M.basicOverlaps cs1 cs2
+        || M.basicOverlaps ds1 ds2
+        || M.basicOverlaps es1 es2
+        || M.basicOverlaps fs1 fs2
+  {-# INLINE basicUnsafeNew  #-}
+  basicUnsafeNew n_
+      = do
+          as <- M.basicUnsafeNew n_
+          bs <- M.basicUnsafeNew n_
+          cs <- M.basicUnsafeNew n_
+          ds <- M.basicUnsafeNew n_
+          es <- M.basicUnsafeNew n_
+          fs <- M.basicUnsafeNew n_
           return $ MV_6 n_ as bs cs ds es fs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
+  {-# INLINE basicUnsafeReplicate  #-}
+  basicUnsafeReplicate n_ (a, b, c, d, e, f)
+      = do
+          as <- M.basicUnsafeReplicate n_ a
+          bs <- M.basicUnsafeReplicate n_ b
+          cs <- M.basicUnsafeReplicate n_ c
+          ds <- M.basicUnsafeReplicate n_ d
+          es <- M.basicUnsafeReplicate n_ e
+          fs <- M.basicUnsafeReplicate n_ f
           return $ MV_6 n_ as bs cs ds es fs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_6 n_ as bs cs ds es fs) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
+  {-# INLINE basicUnsafeRead  #-}
+  basicUnsafeRead (MV_6 n_ as bs cs ds es fs) i_
+      = do
+          a <- M.basicUnsafeRead as i_
+          b <- M.basicUnsafeRead bs i_
+          c <- M.basicUnsafeRead cs i_
+          d <- M.basicUnsafeRead ds i_
+          e <- M.basicUnsafeRead es i_
+          f <- M.basicUnsafeRead fs i_
           return (a, b, c, d, e, f)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-  {-# INLINE clear  #-}
-  clear (MV_6 n_ as bs cs ds es fs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-  {-# INLINE set  #-}
-  set (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
-                                                          bs2
-                                                          cs2
-                                                          ds2
-                                                          es2
-                                                          fs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_6 n_ as bs cs ds es fs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          return $ MV_6 (m_+n_) as bs cs ds es fs
+  {-# INLINE basicUnsafeWrite  #-}
+  basicUnsafeWrite (MV_6 n_ as bs cs ds es fs) i_ (a, b, c, d, e, f)
+      = do
+          M.basicUnsafeWrite as i_ a
+          M.basicUnsafeWrite bs i_ b
+          M.basicUnsafeWrite cs i_ c
+          M.basicUnsafeWrite ds i_ d
+          M.basicUnsafeWrite es i_ e
+          M.basicUnsafeWrite fs i_ f
+  {-# INLINE basicClear  #-}
+  basicClear (MV_6 n_ as bs cs ds es fs)
+      = do
+          M.basicClear as
+          M.basicClear bs
+          M.basicClear cs
+          M.basicClear ds
+          M.basicClear es
+          M.basicClear fs
+  {-# INLINE basicSet  #-}
+  basicSet (MV_6 n_ as bs cs ds es fs) (a, b, c, d, e, f)
+      = do
+          M.basicSet as a
+          M.basicSet bs b
+          M.basicSet cs c
+          M.basicSet ds d
+          M.basicSet es e
+          M.basicSet fs f
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
+                                                               bs2
+                                                               cs2
+                                                               ds2
+                                                               es2
+                                                               fs2)
+      = do
+          M.basicUnsafeCopy as1 as2
+          M.basicUnsafeCopy bs1 bs2
+          M.basicUnsafeCopy cs1 cs2
+          M.basicUnsafeCopy ds1 ds2
+          M.basicUnsafeCopy es1 es2
+          M.basicUnsafeCopy fs1 fs2
+  {-# INLINE basicUnsafeMove  #-}
+  basicUnsafeMove (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (MV_6 n_2 as2
+                                                               bs2
+                                                               cs2
+                                                               ds2
+                                                               es2
+                                                               fs2)
+      = do
+          M.basicUnsafeMove as1 as2
+          M.basicUnsafeMove bs1 bs2
+          M.basicUnsafeMove cs1 cs2
+          M.basicUnsafeMove ds1 ds2
+          M.basicUnsafeMove es1 es2
+          M.basicUnsafeMove fs1 fs2
+  {-# INLINE basicUnsafeGrow  #-}
+  basicUnsafeGrow (MV_6 n_ as bs cs ds es fs) m_
+      = do
+          as' <- M.basicUnsafeGrow as m_
+          bs' <- M.basicUnsafeGrow bs m_
+          cs' <- M.basicUnsafeGrow cs m_
+          ds' <- M.basicUnsafeGrow ds m_
+          es' <- M.basicUnsafeGrow es m_
+          fs' <- M.basicUnsafeGrow fs m_
+          return $ MV_6 (m_+n_) as' bs' cs' ds' es' fs'
 instance (Unbox a,
           Unbox b,
           Unbox c,
           Unbox d,
           Unbox e,
           Unbox f) => G.Vector Vector (a, b, c, d, e, f) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_6 n_ as bs cs ds es fs)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
+  {-# INLINE basicUnsafeFreeze  #-}
+  basicUnsafeFreeze (MV_6 n_ as bs cs ds es fs)
+      = do
+          as' <- G.basicUnsafeFreeze as
+          bs' <- G.basicUnsafeFreeze bs
+          cs' <- G.basicUnsafeFreeze cs
+          ds' <- G.basicUnsafeFreeze ds
+          es' <- G.basicUnsafeFreeze es
+          fs' <- G.basicUnsafeFreeze fs
           return $ V_6 n_ as' bs' cs' ds' es' fs'
+  {-# INLINE basicUnsafeThaw  #-}
+  basicUnsafeThaw (V_6 n_ as bs cs ds es fs)
+      = do
+          as' <- G.basicUnsafeThaw as
+          bs' <- G.basicUnsafeThaw bs
+          cs' <- G.basicUnsafeThaw cs
+          ds' <- G.basicUnsafeThaw ds
+          es' <- G.basicUnsafeThaw es
+          fs' <- G.basicUnsafeThaw fs
+          return $ MV_6 n_ as' bs' cs' ds' es' fs'
   {-# INLINE basicLength  #-}
   basicLength (V_6 n_ as bs cs ds es fs) = n_
   {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_6 n_ as bs cs ds es fs) i_ m_
-      = V_6 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
+  basicUnsafeSlice i_ m_ (V_6 n_ as bs cs ds es fs)
+      = V_6 m_ (G.basicUnsafeSlice i_ m_ as)
+               (G.basicUnsafeSlice i_ m_ bs)
+               (G.basicUnsafeSlice i_ m_ cs)
+               (G.basicUnsafeSlice i_ m_ ds)
+               (G.basicUnsafeSlice i_ m_ es)
+               (G.basicUnsafeSlice i_ m_ fs)
   {-# INLINE basicUnsafeIndexM  #-}
   basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) i_
       = do
@@ -608,1513 +977,123 @@ instance (Unbox a,
           e <- G.basicUnsafeIndexM es i_
           f <- G.basicUnsafeIndexM fs i_
           return (a, b, c, d, e, f)
-data instance MVector s (a, b, c, d, e, f, g)
-    = MV_7 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
-                               (MVector s e)
-                               (MVector s f)
-                               (MVector s g)
-data instance Vector (a, b, c, d, e, f, g)
-    = V_7 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
-                              (Vector e)
-                              (Vector f)
-                              (Vector g)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g) => Unbox (a, b, c, d, e, f, g)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g) => M.MVector MVector (a, b, c, d, e, f, g) where
-  {-# INLINE length  #-}
-  length (MV_7 n_ as bs cs ds es fs gs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_7 n_ as bs cs ds es fs gs) i_ m_
-      = MV_7 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-                (M.unsafeSlice gs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
-                                                            bs2
-                                                            cs2
-                                                            ds2
-                                                            es2
-                                                            fs2
-                                                            gs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          return $ MV_7 n_ as bs cs ds es fs gs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          return $ MV_7 n_ as bs cs ds es fs gs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_7 n_ as bs cs ds es fs gs) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          return (a, b, c, d, e, f, g)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_7 n_ as bs cs ds es fs gs) i_ (a, b, c, d, e, f, g)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-  {-# INLINE clear  #-}
-  clear (MV_7 n_ as bs cs ds es fs gs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-  {-# INLINE set  #-}
-  set (MV_7 n_ as bs cs ds es fs gs) (a, b, c, d, e, f, g)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_7 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1) (MV_7 n_2 as2
+  {-# INLINE basicUnsafeCopy  #-}
+  basicUnsafeCopy (MV_6 n_1 as1 bs1 cs1 ds1 es1 fs1) (V_6 n_2 as2
                                                               bs2
                                                               cs2
                                                               ds2
                                                               es2
-                                                              fs2
-                                                              gs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_7 n_ as bs cs ds es fs gs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          return $ MV_7 (m_+n_) as bs cs ds es fs gs
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g) => G.Vector Vector (a, b, c, d, e, f, g) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_7 n_ as bs cs ds es fs gs)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
-          gs' <- G.unsafeFreeze gs
-          return $ V_7 n_ as' bs' cs' ds' es' fs' gs'
-  {-# INLINE basicLength  #-}
-  basicLength (V_7 n_ as bs cs ds es fs gs) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_7 n_ as bs cs ds es fs gs) i_ m_
-      = V_7 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
-               (G.unsafeSlice gs i_ m_)
-  {-# INLINE basicUnsafeIndexM  #-}
-  basicUnsafeIndexM (V_7 n_ as bs cs ds es fs gs) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          c <- G.basicUnsafeIndexM cs i_
-          d <- G.basicUnsafeIndexM ds i_
-          e <- G.basicUnsafeIndexM es i_
-          f <- G.basicUnsafeIndexM fs i_
-          g <- G.basicUnsafeIndexM gs i_
-          return (a, b, c, d, e, f, g)
-data instance MVector s (a, b, c, d, e, f, g, h)
-    = MV_8 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
-                               (MVector s e)
-                               (MVector s f)
-                               (MVector s g)
-                               (MVector s h)
-data instance Vector (a, b, c, d, e, f, g, h)
-    = V_8 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
-                              (Vector e)
-                              (Vector f)
-                              (Vector g)
-                              (Vector h)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h) => Unbox (a, b, c, d, e, f, g, h)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h) => M.MVector MVector (a, b, c, d, e, f, g, h) where
-  {-# INLINE length  #-}
-  length (MV_8 n_ as bs cs ds es fs gs hs) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_8 n_ as bs cs ds es fs gs hs) i_ m_
-      = MV_8 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-                (M.unsafeSlice gs i_ m_)
-                (M.unsafeSlice hs i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_8 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1 hs1) (MV_8 n_2 as2
-                                                                bs2
-                                                                cs2
-                                                                ds2
-                                                                es2
-                                                                fs2
-                                                                gs2
-                                                                hs2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          return $ MV_8 n_ as bs cs ds es fs gs hs
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          return $ MV_8 n_ as bs cs ds es fs gs hs
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_8 n_ as bs cs ds es fs gs hs) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          return (a, b, c, d, e, f, g, h)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_8 n_ as
-                       bs
-                       cs
-                       ds
-                       es
-                       fs
-                       gs
-                       hs) i_ (a, b, c, d, e, f, g, h)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-  {-# INLINE clear  #-}
-  clear (MV_8 n_ as bs cs ds es fs gs hs)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-  {-# INLINE set  #-}
-  set (MV_8 n_ as bs cs ds es fs gs hs) (a, b, c, d, e, f, g, h)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_8 n_1 as1 bs1 cs1 ds1 es1 fs1 gs1 hs1) (MV_8 n_2 as2
-                                                                  bs2
-                                                                  cs2
-                                                                  ds2
-                                                                  es2
-                                                                  fs2
-                                                                  gs2
-                                                                  hs2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_8 n_ as bs cs ds es fs gs hs) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          return $ MV_8 (m_+n_) as bs cs ds es fs gs hs
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h) => G.Vector Vector (a, b, c, d, e, f, g, h) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_8 n_ as bs cs ds es fs gs hs)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
-          gs' <- G.unsafeFreeze gs
-          hs' <- G.unsafeFreeze hs
-          return $ V_8 n_ as' bs' cs' ds' es' fs' gs' hs'
-  {-# INLINE basicLength  #-}
-  basicLength (V_8 n_ as bs cs ds es fs gs hs) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_8 n_ as bs cs ds es fs gs hs) i_ m_
-      = V_8 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
-               (G.unsafeSlice gs i_ m_)
-               (G.unsafeSlice hs i_ m_)
-  {-# INLINE basicUnsafeIndexM  #-}
-  basicUnsafeIndexM (V_8 n_ as bs cs ds es fs gs hs) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          c <- G.basicUnsafeIndexM cs i_
-          d <- G.basicUnsafeIndexM ds i_
-          e <- G.basicUnsafeIndexM es i_
-          f <- G.basicUnsafeIndexM fs i_
-          g <- G.basicUnsafeIndexM gs i_
-          h <- G.basicUnsafeIndexM hs i_
-          return (a, b, c, d, e, f, g, h)
-data instance MVector s (a, b, c, d, e, f, g, h, i)
-    = MV_9 {-# UNPACK #-} !Int (MVector s a)
-                               (MVector s b)
-                               (MVector s c)
-                               (MVector s d)
-                               (MVector s e)
-                               (MVector s f)
-                               (MVector s g)
-                               (MVector s h)
-                               (MVector s i)
-data instance Vector (a, b, c, d, e, f, g, h, i)
-    = V_9 {-# UNPACK #-} !Int (Vector a)
-                              (Vector b)
-                              (Vector c)
-                              (Vector d)
-                              (Vector e)
-                              (Vector f)
-                              (Vector g)
-                              (Vector h)
-                              (Vector i)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i) => Unbox (a, b, c, d, e, f, g, h, i)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i) => M.MVector MVector (a, b, c, d, e, f, g, h, i) where
-  {-# INLINE length  #-}
-  length (MV_9 n_ as bs cs ds es fs gs hs is) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_9 n_ as bs cs ds es fs gs hs is) i_ m_
-      = MV_9 m_ (M.unsafeSlice as i_ m_)
-                (M.unsafeSlice bs i_ m_)
-                (M.unsafeSlice cs i_ m_)
-                (M.unsafeSlice ds i_ m_)
-                (M.unsafeSlice es i_ m_)
-                (M.unsafeSlice fs i_ m_)
-                (M.unsafeSlice gs i_ m_)
-                (M.unsafeSlice hs i_ m_)
-                (M.unsafeSlice is i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_9 n_1 as1
-                     bs1
-                     cs1
-                     ds1
-                     es1
-                     fs1
-                     gs1
-                     hs1
-                     is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
-          return $ MV_9 n_ as bs cs ds es fs gs hs is
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
-          return $ MV_9 n_ as bs cs ds es fs gs hs is
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_9 n_ as bs cs ds es fs gs hs is) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
-          return (a, b, c, d, e, f, g, h, i)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_9 n_ as
-                       bs
-                       cs
-                       ds
-                       es
-                       fs
-                       gs
-                       hs
-                       is) i_ (a, b, c, d, e, f, g, h, i)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-  {-# INLINE clear  #-}
-  clear (MV_9 n_ as bs cs ds es fs gs hs is)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-  {-# INLINE set  #-}
-  set (MV_9 n_ as
-               bs
-               cs
-               ds
-               es
-               fs
-               gs
-               hs
-               is) (a, b, c, d, e, f, g, h, i)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_9 n_1 as1
-                       bs1
-                       cs1
-                       ds1
-                       es1
-                       fs1
-                       gs1
-                       hs1
-                       is1) (MV_9 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_9 n_ as bs cs ds es fs gs hs is) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
-          return $ MV_9 (m_+n_) as bs cs ds es fs gs hs is
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i) => G.Vector Vector (a, b, c, d, e, f, g, h, i) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_9 n_ as bs cs ds es fs gs hs is)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
-          gs' <- G.unsafeFreeze gs
-          hs' <- G.unsafeFreeze hs
-          is' <- G.unsafeFreeze is
-          return $ V_9 n_ as' bs' cs' ds' es' fs' gs' hs' is'
-  {-# INLINE basicLength  #-}
-  basicLength (V_9 n_ as bs cs ds es fs gs hs is) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_9 n_ as bs cs ds es fs gs hs is) i_ m_
-      = V_9 m_ (G.unsafeSlice as i_ m_)
-               (G.unsafeSlice bs i_ m_)
-               (G.unsafeSlice cs i_ m_)
-               (G.unsafeSlice ds i_ m_)
-               (G.unsafeSlice es i_ m_)
-               (G.unsafeSlice fs i_ m_)
-               (G.unsafeSlice gs i_ m_)
-               (G.unsafeSlice hs i_ m_)
-               (G.unsafeSlice is i_ m_)
-  {-# INLINE basicUnsafeIndexM  #-}
-  basicUnsafeIndexM (V_9 n_ as bs cs ds es fs gs hs is) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          c <- G.basicUnsafeIndexM cs i_
-          d <- G.basicUnsafeIndexM ds i_
-          e <- G.basicUnsafeIndexM es i_
-          f <- G.basicUnsafeIndexM fs i_
-          g <- G.basicUnsafeIndexM gs i_
-          h <- G.basicUnsafeIndexM hs i_
-          i <- G.basicUnsafeIndexM is i_
-          return (a, b, c, d, e, f, g, h, i)
-data instance MVector s (a, b, c, d, e, f, g, h, i, j)
-    = MV_10 {-# UNPACK #-} !Int (MVector s a)
-                                (MVector s b)
-                                (MVector s c)
-                                (MVector s d)
-                                (MVector s e)
-                                (MVector s f)
-                                (MVector s g)
-                                (MVector s h)
-                                (MVector s i)
-                                (MVector s j)
-data instance Vector (a, b, c, d, e, f, g, h, i, j)
-    = V_10 {-# UNPACK #-} !Int (Vector a)
-                               (Vector b)
-                               (Vector c)
-                               (Vector d)
-                               (Vector e)
-                               (Vector f)
-                               (Vector g)
-                               (Vector h)
-                               (Vector i)
-                               (Vector j)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j) => Unbox (a, b, c, d, e, f, g, h, i, j)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j) where
-  {-# INLINE length  #-}
-  length (MV_10 n_ as bs cs ds es fs gs hs is js) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_10 n_ as bs cs ds es fs gs hs is js) i_ m_
-      = MV_10 m_ (M.unsafeSlice as i_ m_)
-                 (M.unsafeSlice bs i_ m_)
-                 (M.unsafeSlice cs i_ m_)
-                 (M.unsafeSlice ds i_ m_)
-                 (M.unsafeSlice es i_ m_)
-                 (M.unsafeSlice fs i_ m_)
-                 (M.unsafeSlice gs i_ m_)
-                 (M.unsafeSlice hs i_ m_)
-                 (M.unsafeSlice is i_ m_)
-                 (M.unsafeSlice js i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_10 n_1 as1
-                      bs1
-                      cs1
-                      ds1
-                      es1
-                      fs1
-                      gs1
-                      hs1
-                      is1
-                      js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-        || M.overlaps js1 js2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
-          js <- M.unsafeNew n_
-          return $ MV_10 n_ as bs cs ds es fs gs hs is js
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
-          js <- M.unsafeNewWith n_ j
-          return $ MV_10 n_ as bs cs ds es fs gs hs is js
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_10 n_ as bs cs ds es fs gs hs is js) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
-          j <- M.unsafeRead js i_
-          return (a, b, c, d, e, f, g, h, i, j)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_10 n_ as
-                        bs
-                        cs
-                        ds
-                        es
-                        fs
-                        gs
-                        hs
-                        is
-                        js) i_ (a, b, c, d, e, f, g, h, i, j)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-          M.unsafeWrite js i_ j
-  {-# INLINE clear  #-}
-  clear (MV_10 n_ as bs cs ds es fs gs hs is js)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-          M.clear js
-  {-# INLINE set  #-}
-  set (MV_10 n_ as
-                bs
-                cs
-                ds
-                es
-                fs
-                gs
-                hs
-                is
-                js) (a, b, c, d, e, f, g, h, i, j)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-          M.set js j
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_10 n_1 as1
-                        bs1
-                        cs1
-                        ds1
-                        es1
-                        fs1
-                        gs1
-                        hs1
-                        is1
-                        js1) (MV_10 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-          M.unsafeCopy js1 js2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_10 n_ as bs cs ds es fs gs hs is js) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
-          M.unsafeGrow js m_
-          return $ MV_10 (m_+n_) as bs cs ds es fs gs hs is js
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_10 n_ as bs cs ds es fs gs hs is js)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
-          gs' <- G.unsafeFreeze gs
-          hs' <- G.unsafeFreeze hs
-          is' <- G.unsafeFreeze is
-          js' <- G.unsafeFreeze js
-          return $ V_10 n_ as' bs' cs' ds' es' fs' gs' hs' is' js'
-  {-# INLINE basicLength  #-}
-  basicLength (V_10 n_ as bs cs ds es fs gs hs is js) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_10 n_ as bs cs ds es fs gs hs is js) i_ m_
-      = V_10 m_ (G.unsafeSlice as i_ m_)
-                (G.unsafeSlice bs i_ m_)
-                (G.unsafeSlice cs i_ m_)
-                (G.unsafeSlice ds i_ m_)
-                (G.unsafeSlice es i_ m_)
-                (G.unsafeSlice fs i_ m_)
-                (G.unsafeSlice gs i_ m_)
-                (G.unsafeSlice hs i_ m_)
-                (G.unsafeSlice is i_ m_)
-                (G.unsafeSlice js i_ m_)
-  {-# INLINE basicUnsafeIndexM  #-}
-  basicUnsafeIndexM (V_10 n_ as bs cs ds es fs gs hs is js) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          c <- G.basicUnsafeIndexM cs i_
-          d <- G.basicUnsafeIndexM ds i_
-          e <- G.basicUnsafeIndexM es i_
-          f <- G.basicUnsafeIndexM fs i_
-          g <- G.basicUnsafeIndexM gs i_
-          h <- G.basicUnsafeIndexM hs i_
-          i <- G.basicUnsafeIndexM is i_
-          j <- G.basicUnsafeIndexM js i_
-          return (a, b, c, d, e, f, g, h, i, j)
-data instance MVector s (a, b, c, d, e, f, g, h, i, j, k)
-    = MV_11 {-# UNPACK #-} !Int (MVector s a)
-                                (MVector s b)
-                                (MVector s c)
-                                (MVector s d)
-                                (MVector s e)
-                                (MVector s f)
-                                (MVector s g)
-                                (MVector s h)
-                                (MVector s i)
-                                (MVector s j)
-                                (MVector s k)
-data instance Vector (a, b, c, d, e, f, g, h, i, j, k)
-    = V_11 {-# UNPACK #-} !Int (Vector a)
-                               (Vector b)
-                               (Vector c)
-                               (Vector d)
-                               (Vector e)
-                               (Vector f)
-                               (Vector g)
-                               (Vector h)
-                               (Vector i)
-                               (Vector j)
-                               (Vector k)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j,
-          Unbox k) => Unbox (a, b, c, d, e, f, g, h, i, j, k)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j,
-          Unbox k) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k) where
-  {-# INLINE length  #-}
-  length (MV_11 n_ as bs cs ds es fs gs hs is js ks) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
-      = MV_11 m_ (M.unsafeSlice as i_ m_)
-                 (M.unsafeSlice bs i_ m_)
-                 (M.unsafeSlice cs i_ m_)
-                 (M.unsafeSlice ds i_ m_)
-                 (M.unsafeSlice es i_ m_)
-                 (M.unsafeSlice fs i_ m_)
-                 (M.unsafeSlice gs i_ m_)
-                 (M.unsafeSlice hs i_ m_)
-                 (M.unsafeSlice is i_ m_)
-                 (M.unsafeSlice js i_ m_)
-                 (M.unsafeSlice ks i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_11 n_1 as1
-                      bs1
-                      cs1
-                      ds1
-                      es1
-                      fs1
-                      gs1
-                      hs1
-                      is1
-                      js1
-                      ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-        || M.overlaps js1 js2
-        || M.overlaps ks1 ks2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
-          js <- M.unsafeNew n_
-          ks <- M.unsafeNew n_
-          return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
-          js <- M.unsafeNewWith n_ j
-          ks <- M.unsafeNewWith n_ k
-          return $ MV_11 n_ as bs cs ds es fs gs hs is js ks
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_11 n_ as bs cs ds es fs gs hs is js ks) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
-          j <- M.unsafeRead js i_
-          k <- M.unsafeRead ks i_
-          return (a, b, c, d, e, f, g, h, i, j, k)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_11 n_ as
-                        bs
-                        cs
-                        ds
-                        es
-                        fs
-                        gs
-                        hs
-                        is
-                        js
-                        ks) i_ (a, b, c, d, e, f, g, h, i, j, k)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-          M.unsafeWrite js i_ j
-          M.unsafeWrite ks i_ k
-  {-# INLINE clear  #-}
-  clear (MV_11 n_ as bs cs ds es fs gs hs is js ks)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-          M.clear js
-          M.clear ks
-  {-# INLINE set  #-}
-  set (MV_11 n_ as
-                bs
-                cs
-                ds
-                es
-                fs
-                gs
-                hs
-                is
-                js
-                ks) (a, b, c, d, e, f, g, h, i, j, k)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-          M.set js j
-          M.set ks k
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_11 n_1 as1
-                        bs1
-                        cs1
-                        ds1
-                        es1
-                        fs1
-                        gs1
-                        hs1
-                        is1
-                        js1
-                        ks1) (MV_11 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-          M.unsafeCopy js1 js2
-          M.unsafeCopy ks1 ks2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_11 n_ as bs cs ds es fs gs hs is js ks) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
-          M.unsafeGrow js m_
-          M.unsafeGrow ks m_
-          return $ MV_11 (m_+n_) as bs cs ds es fs gs hs is js ks
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j,
-          Unbox k) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j, k) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_11 n_ as bs cs ds es fs gs hs is js ks)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
-          gs' <- G.unsafeFreeze gs
-          hs' <- G.unsafeFreeze hs
-          is' <- G.unsafeFreeze is
-          js' <- G.unsafeFreeze js
-          ks' <- G.unsafeFreeze ks
-          return $ V_11 n_ as' bs' cs' ds' es' fs' gs' hs' is' js' ks'
-  {-# INLINE basicLength  #-}
-  basicLength (V_11 n_ as bs cs ds es fs gs hs is js ks) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_11 n_ as bs cs ds es fs gs hs is js ks) i_ m_
-      = V_11 m_ (G.unsafeSlice as i_ m_)
-                (G.unsafeSlice bs i_ m_)
-                (G.unsafeSlice cs i_ m_)
-                (G.unsafeSlice ds i_ m_)
-                (G.unsafeSlice es i_ m_)
-                (G.unsafeSlice fs i_ m_)
-                (G.unsafeSlice gs i_ m_)
-                (G.unsafeSlice hs i_ m_)
-                (G.unsafeSlice is i_ m_)
-                (G.unsafeSlice js i_ m_)
-                (G.unsafeSlice ks i_ m_)
-  {-# INLINE basicUnsafeIndexM  #-}
-  basicUnsafeIndexM (V_11 n_ as bs cs ds es fs gs hs is js ks) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          c <- G.basicUnsafeIndexM cs i_
-          d <- G.basicUnsafeIndexM ds i_
-          e <- G.basicUnsafeIndexM es i_
-          f <- G.basicUnsafeIndexM fs i_
-          g <- G.basicUnsafeIndexM gs i_
-          h <- G.basicUnsafeIndexM hs i_
-          i <- G.basicUnsafeIndexM is i_
-          j <- G.basicUnsafeIndexM js i_
-          k <- G.basicUnsafeIndexM ks i_
-          return (a, b, c, d, e, f, g, h, i, j, k)
-data instance MVector s (a, b, c, d, e, f, g, h, i, j, k, l)
-    = MV_12 {-# UNPACK #-} !Int (MVector s a)
-                                (MVector s b)
-                                (MVector s c)
-                                (MVector s d)
-                                (MVector s e)
-                                (MVector s f)
-                                (MVector s g)
-                                (MVector s h)
-                                (MVector s i)
-                                (MVector s j)
-                                (MVector s k)
-                                (MVector s l)
-data instance Vector (a, b, c, d, e, f, g, h, i, j, k, l)
-    = V_12 {-# UNPACK #-} !Int (Vector a)
-                               (Vector b)
-                               (Vector c)
-                               (Vector d)
-                               (Vector e)
-                               (Vector f)
-                               (Vector g)
-                               (Vector h)
-                               (Vector i)
-                               (Vector j)
-                               (Vector k)
-                               (Vector l)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j,
-          Unbox k,
-          Unbox l) => Unbox (a, b, c, d, e, f, g, h, i, j, k, l)
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j,
-          Unbox k,
-          Unbox l) => M.MVector MVector (a, b, c, d, e, f, g, h, i, j, k, l) where
-  {-# INLINE length  #-}
-  length (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
-  {-# INLINE unsafeSlice  #-}
-  unsafeSlice (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_ m_
-      = MV_12 m_ (M.unsafeSlice as i_ m_)
-                 (M.unsafeSlice bs i_ m_)
-                 (M.unsafeSlice cs i_ m_)
-                 (M.unsafeSlice ds i_ m_)
-                 (M.unsafeSlice es i_ m_)
-                 (M.unsafeSlice fs i_ m_)
-                 (M.unsafeSlice gs i_ m_)
-                 (M.unsafeSlice hs i_ m_)
-                 (M.unsafeSlice is i_ m_)
-                 (M.unsafeSlice js i_ m_)
-                 (M.unsafeSlice ks i_ m_)
-                 (M.unsafeSlice ls i_ m_)
-  {-# INLINE overlaps  #-}
-  overlaps (MV_12 n_1 as1
-                      bs1
-                      cs1
-                      ds1
-                      es1
-                      fs1
-                      gs1
-                      hs1
-                      is1
-                      js1
-                      ks1
-                      ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
-      = M.overlaps as1 as2
-        || M.overlaps bs1 bs2
-        || M.overlaps cs1 cs2
-        || M.overlaps ds1 ds2
-        || M.overlaps es1 es2
-        || M.overlaps fs1 fs2
-        || M.overlaps gs1 gs2
-        || M.overlaps hs1 hs2
-        || M.overlaps is1 is2
-        || M.overlaps js1 js2
-        || M.overlaps ks1 ks2
-        || M.overlaps ls1 ls2
-  {-# INLINE unsafeNew  #-}
-  unsafeNew n_
-      = do
-          as <- M.unsafeNew n_
-          bs <- M.unsafeNew n_
-          cs <- M.unsafeNew n_
-          ds <- M.unsafeNew n_
-          es <- M.unsafeNew n_
-          fs <- M.unsafeNew n_
-          gs <- M.unsafeNew n_
-          hs <- M.unsafeNew n_
-          is <- M.unsafeNew n_
-          js <- M.unsafeNew n_
-          ks <- M.unsafeNew n_
-          ls <- M.unsafeNew n_
-          return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
-  {-# INLINE unsafeNewWith  #-}
-  unsafeNewWith n_ (a, b, c, d, e, f, g, h, i, j, k, l)
-      = do
-          as <- M.unsafeNewWith n_ a
-          bs <- M.unsafeNewWith n_ b
-          cs <- M.unsafeNewWith n_ c
-          ds <- M.unsafeNewWith n_ d
-          es <- M.unsafeNewWith n_ e
-          fs <- M.unsafeNewWith n_ f
-          gs <- M.unsafeNewWith n_ g
-          hs <- M.unsafeNewWith n_ h
-          is <- M.unsafeNewWith n_ i
-          js <- M.unsafeNewWith n_ j
-          ks <- M.unsafeNewWith n_ k
-          ls <- M.unsafeNewWith n_ l
-          return $ MV_12 n_ as bs cs ds es fs gs hs is js ks ls
-  {-# INLINE unsafeRead  #-}
-  unsafeRead (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
-      = do
-          a <- M.unsafeRead as i_
-          b <- M.unsafeRead bs i_
-          c <- M.unsafeRead cs i_
-          d <- M.unsafeRead ds i_
-          e <- M.unsafeRead es i_
-          f <- M.unsafeRead fs i_
-          g <- M.unsafeRead gs i_
-          h <- M.unsafeRead hs i_
-          i <- M.unsafeRead is i_
-          j <- M.unsafeRead js i_
-          k <- M.unsafeRead ks i_
-          l <- M.unsafeRead ls i_
-          return (a, b, c, d, e, f, g, h, i, j, k, l)
-  {-# INLINE unsafeWrite  #-}
-  unsafeWrite (MV_12 n_ as
-                        bs
-                        cs
-                        ds
-                        es
-                        fs
-                        gs
-                        hs
-                        is
-                        js
-                        ks
-                        ls) i_ (a, b, c, d, e, f, g, h, i, j, k, l)
-      = do
-          M.unsafeWrite as i_ a
-          M.unsafeWrite bs i_ b
-          M.unsafeWrite cs i_ c
-          M.unsafeWrite ds i_ d
-          M.unsafeWrite es i_ e
-          M.unsafeWrite fs i_ f
-          M.unsafeWrite gs i_ g
-          M.unsafeWrite hs i_ h
-          M.unsafeWrite is i_ i
-          M.unsafeWrite js i_ j
-          M.unsafeWrite ks i_ k
-          M.unsafeWrite ls i_ l
-  {-# INLINE clear  #-}
-  clear (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
-      = do
-          M.clear as
-          M.clear bs
-          M.clear cs
-          M.clear ds
-          M.clear es
-          M.clear fs
-          M.clear gs
-          M.clear hs
-          M.clear is
-          M.clear js
-          M.clear ks
-          M.clear ls
-  {-# INLINE set  #-}
-  set (MV_12 n_ as
-                bs
-                cs
-                ds
-                es
-                fs
-                gs
-                hs
-                is
-                js
-                ks
-                ls) (a, b, c, d, e, f, g, h, i, j, k, l)
-      = do
-          M.set as a
-          M.set bs b
-          M.set cs c
-          M.set ds d
-          M.set es e
-          M.set fs f
-          M.set gs g
-          M.set hs h
-          M.set is i
-          M.set js j
-          M.set ks k
-          M.set ls l
-  {-# INLINE unsafeCopy  #-}
-  unsafeCopy (MV_12 n_1 as1
-                        bs1
-                        cs1
-                        ds1
-                        es1
-                        fs1
-                        gs1
-                        hs1
-                        is1
-                        js1
-                        ks1
-                        ls1) (MV_12 n_2 as2 bs2 cs2 ds2 es2 fs2 gs2 hs2 is2 js2 ks2 ls2)
-      = do
-          M.unsafeCopy as1 as2
-          M.unsafeCopy bs1 bs2
-          M.unsafeCopy cs1 cs2
-          M.unsafeCopy ds1 ds2
-          M.unsafeCopy es1 es2
-          M.unsafeCopy fs1 fs2
-          M.unsafeCopy gs1 gs2
-          M.unsafeCopy hs1 hs2
-          M.unsafeCopy is1 is2
-          M.unsafeCopy js1 js2
-          M.unsafeCopy ks1 ks2
-          M.unsafeCopy ls1 ls2
-  {-# INLINE unsafeGrow  #-}
-  unsafeGrow (MV_12 n_ as bs cs ds es fs gs hs is js ks ls) m_
-      = do
-          M.unsafeGrow as m_
-          M.unsafeGrow bs m_
-          M.unsafeGrow cs m_
-          M.unsafeGrow ds m_
-          M.unsafeGrow es m_
-          M.unsafeGrow fs m_
-          M.unsafeGrow gs m_
-          M.unsafeGrow hs m_
-          M.unsafeGrow is m_
-          M.unsafeGrow js m_
-          M.unsafeGrow ks m_
-          M.unsafeGrow ls m_
-          return $ MV_12 (m_+n_) as bs cs ds es fs gs hs is js ks ls
-instance (Unbox a,
-          Unbox b,
-          Unbox c,
-          Unbox d,
-          Unbox e,
-          Unbox f,
-          Unbox g,
-          Unbox h,
-          Unbox i,
-          Unbox j,
-          Unbox k,
-          Unbox l) => G.Vector Vector (a, b, c, d, e, f, g, h, i, j, k, l) where
-  {-# INLINE unsafeFreeze  #-}
-  unsafeFreeze (MV_12 n_ as bs cs ds es fs gs hs is js ks ls)
-      = do
-          as' <- G.unsafeFreeze as
-          bs' <- G.unsafeFreeze bs
-          cs' <- G.unsafeFreeze cs
-          ds' <- G.unsafeFreeze ds
-          es' <- G.unsafeFreeze es
-          fs' <- G.unsafeFreeze fs
-          gs' <- G.unsafeFreeze gs
-          hs' <- G.unsafeFreeze hs
-          is' <- G.unsafeFreeze is
-          js' <- G.unsafeFreeze js
-          ks' <- G.unsafeFreeze ks
-          ls' <- G.unsafeFreeze ls
-          return $ V_12 n_ as' bs' cs' ds' es' fs' gs' hs' is' js' ks' ls'
-  {-# INLINE basicLength  #-}
-  basicLength (V_12 n_ as bs cs ds es fs gs hs is js ks ls) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice (V_12 n_ as
-                            bs
-                            cs
-                            ds
-                            es
-                            fs
-                            gs
-                            hs
-                            is
-                            js
-                            ks
-                            ls) i_ m_
-      = V_12 m_ (G.unsafeSlice as i_ m_)
-                (G.unsafeSlice bs i_ m_)
-                (G.unsafeSlice cs i_ m_)
-                (G.unsafeSlice ds i_ m_)
-                (G.unsafeSlice es i_ m_)
-                (G.unsafeSlice fs i_ m_)
-                (G.unsafeSlice gs i_ m_)
-                (G.unsafeSlice hs i_ m_)
-                (G.unsafeSlice is i_ m_)
-                (G.unsafeSlice js i_ m_)
-                (G.unsafeSlice ks i_ m_)
-                (G.unsafeSlice ls i_ m_)
-  {-# INLINE basicUnsafeIndexM  #-}
-  basicUnsafeIndexM (V_12 n_ as bs cs ds es fs gs hs is js ks ls) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          c <- G.basicUnsafeIndexM cs i_
-          d <- G.basicUnsafeIndexM ds i_
-          e <- G.basicUnsafeIndexM es i_
-          f <- G.basicUnsafeIndexM fs i_
-          g <- G.basicUnsafeIndexM gs i_
-          h <- G.basicUnsafeIndexM hs i_
-          i <- G.basicUnsafeIndexM is i_
-          j <- G.basicUnsafeIndexM js i_
-          k <- G.basicUnsafeIndexM ks i_
-          l <- G.basicUnsafeIndexM ls i_
-          return (a, b, c, d, e, f, g, h, i, j, k, l)
+                                                              fs2)
+      = do
+          G.basicUnsafeCopy as1 as2
+          G.basicUnsafeCopy bs1 bs2
+          G.basicUnsafeCopy cs1 cs2
+          G.basicUnsafeCopy ds1 ds2
+          G.basicUnsafeCopy es1 es2
+          G.basicUnsafeCopy fs1 fs2
+  {-# INLINE elemseq  #-}
+  elemseq _ (a, b, c, d, e, f)
+      = G.elemseq (undefined :: Vector a) a
+        . G.elemseq (undefined :: Vector b) b
+        . G.elemseq (undefined :: Vector c) c
+        . G.elemseq (undefined :: Vector d) d
+        . G.elemseq (undefined :: Vector e) e
+        . G.elemseq (undefined :: Vector f) f
+#endif
+#ifdef DEFINE_MUTABLE
+-- | /O(1)/ Zip 6 vectors
+zip6 :: (Unbox a,
+         Unbox b,
+         Unbox c,
+         Unbox d,
+         Unbox e,
+         Unbox f) => MVector s a ->
+                     MVector s b ->
+                     MVector s c ->
+                     MVector s d ->
+                     MVector s e ->
+                     MVector s f -> MVector s (a, b, c, d, e, f)
+{-# INLINE_FUSED zip6 #-}
+zip6 as bs cs ds es fs = MV_6 len (unsafeSlice 0 len as)
+                                  (unsafeSlice 0 len bs)
+                                  (unsafeSlice 0 len cs)
+                                  (unsafeSlice 0 len ds)
+                                  (unsafeSlice 0 len es)
+                                  (unsafeSlice 0 len fs)
+  where
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
+          length es `delayed_min`
+          length fs
+-- | /O(1)/ Unzip 6 vectors
+unzip6 :: (Unbox a,
+           Unbox b,
+           Unbox c,
+           Unbox d,
+           Unbox e,
+           Unbox f) => MVector s (a, b, c, d, e, f) -> (MVector s a,
+                                                        MVector s b,
+                                                        MVector s c,
+                                                        MVector s d,
+                                                        MVector s e,
+                                                        MVector s f)
+{-# INLINE unzip6 #-}
+unzip6 (MV_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
+#endif
+#ifdef DEFINE_IMMUTABLE
+-- | /O(1)/ Zip 6 vectors
+zip6 :: (Unbox a,
+         Unbox b,
+         Unbox c,
+         Unbox d,
+         Unbox e,
+         Unbox f) => Vector a ->
+                     Vector b ->
+                     Vector c ->
+                     Vector d ->
+                     Vector e ->
+                     Vector f -> Vector (a, b, c, d, e, f)
+{-# INLINE_FUSED zip6 #-}
+zip6 as bs cs ds es fs = V_6 len (unsafeSlice 0 len as)
+                                 (unsafeSlice 0 len bs)
+                                 (unsafeSlice 0 len cs)
+                                 (unsafeSlice 0 len ds)
+                                 (unsafeSlice 0 len es)
+                                 (unsafeSlice 0 len fs)
+  where
+    len = length as `delayed_min`
+          length bs `delayed_min`
+          length cs `delayed_min`
+          length ds `delayed_min`
+          length es `delayed_min`
+          length fs
+{-# RULES "stream/zip6 [Vector.Unboxed]" forall as bs cs ds es fs .
+  G.stream (zip6 as
+                 bs
+                 cs
+                 ds
+                 es
+                 fs) = Stream.zipWith6 (, , , , ,) (G.stream as)
+                                                   (G.stream bs)
+                                                   (G.stream cs)
+                                                   (G.stream ds)
+                                                   (G.stream es)
+                                                   (G.stream fs)
+  #-}
+-- | /O(1)/ Unzip 6 vectors
+unzip6 :: (Unbox a,
+           Unbox b,
+           Unbox c,
+           Unbox d,
+           Unbox e,
+           Unbox f) => Vector (a, b, c, d, e, f) -> (Vector a,
+                                                     Vector b,
+                                                     Vector c,
+                                                     Vector d,
+                                                     Vector e,
+                                                     Vector f)
+{-# INLINE unzip6 #-}
+unzip6 (V_6 n_ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
+#endif