Generate Unbox instances for tuples
authorRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sun, 6 Dec 2009 00:53:53 +0000 (00:53 +0000)
committerRoman Leshchinskiy <rl@cse.unsw.edu.au>
Sun, 6 Dec 2009 00:53:53 +0000 (00:53 +0000)
Data/Vector/Unboxed/Unbox.hs
internal/GenUnboxTuple.hs [moved from util/GenUnboxTuple.hs with 73% similarity]
internal/unbox-tuple-instances [new file with mode: 0644]
vector.cabal

index 8ec9c4c..6095078 100644 (file)
@@ -261,74 +261,5 @@ instance G.Vector Vector Bool where
 -- Tuples
 -- ------
 
 -- Tuples
 -- ------
 
-data instance MVector s (a,b) = MV_2 {-# UNPACK #-} !Int
-                                                    (MVector s a)
-                                                    (MVector s b)
-data instance Vector    (a,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 #-}
-  {-# INLINE unsafeSlice #-}
-  {-# INLINE overlaps #-}
-  {-# INLINE unsafeNew #-}
-  {-# INLINE unsafeNewWith #-}
-  {-# INLINE unsafeRead #-}
-  {-# INLINE unsafeWrite #-}
-  {-# INLINE clear #-}
-  {-# INLINE set #-}
-  {-# INLINE unsafeCopy #-}
-  {-# INLINE unsafeGrow #-}
-
-  length (MV_2 n as bs) = n
-
-  unsafeSlice (MV_2 n as bs) i m
-    = UNSAFE_CHECK(checkSlice) "unsafeSlice" i m n
-    $ MV_2 m (M.unsafeSlice as i m)
-             (M.unsafeSlice bs i m)
-
-  overlaps (MV_2 _ as1 bs1) (MV_2 _ as2 bs2)
-    = M.overlaps as1 as2 || M.overlaps bs1 bs2
-
-  unsafeNew n = liftM2 (MV_2 n) (M.unsafeNew n) (M.unsafeNew n)
-  unsafeNewWith n (a,b) = liftM2 (MV_2 n) (M.unsafeNewWith n a)
-                                          (M.unsafeNewWith n b)
-
-  unsafeRead (MV_2 _ as bs) i = liftM2 (,) (M.unsafeRead as i)
-                                           (M.unsafeRead bs i)
-
-  unsafeWrite (MV_2 _ as bs) i (a,b)
-    = do { M.unsafeWrite as i a ; M.unsafeWrite bs i b }
-
-  clear (MV_2 _ as bs) = do { M.clear as ; M.clear bs }
-
-  set (MV_2 _ as bs) (a,b) = do { M.set as a ; M.set bs b }
-
-  unsafeCopy (MV_2 _ as1 bs1) (MV_2 _ as2 bs2)
-    = do { M.unsafeCopy as1 as2 ; M.unsafeCopy bs1 bs2 }
-
-  unsafeGrow (MV_2 n as bs) m
-    = liftM2 (MV_2 $ m+n) (M.unsafeGrow as m) (M.unsafeGrow bs m)
-
-instance (Unbox a, Unbox b) => G.Vector Vector (a,b) where
-  {-# INLINE unsafeFreeze #-}
-  {-# INLINE basicLength #-}
-  {-# INLINE basicUnsafeSlice #-}
-  {-# INLINE basicUnsafeIndexM #-}
-
-  unsafeFreeze (MV_2 n as bs)
-    = liftM2 (V_2 n) (G.unsafeFreeze as) (G.unsafeFreeze bs)
-
-  basicLength (V_2 n _ _) = n
-
-  basicUnsafeSlice (V_2 _ as bs) i n
-    = V_2 n (G.basicUnsafeSlice as i n)
-            (G.basicUnsafeSlice bs i n)
-
-  basicUnsafeIndexM (V_2 _ as bs) i
-    = liftM2 (,) (G.basicUnsafeIndexM as i)
-                 (G.basicUnsafeIndexM bs i)
+#include "unbox-tuple-instances"
 
 
similarity index 73%
rename from util/GenUnboxTuple.hs
rename to internal/GenUnboxTuple.hs
index b413604..04e7df1 100644 (file)
@@ -27,6 +27,7 @@ generate n =
     tuple f = parens $ hsep $ punctuate comma $ map f vars
     vtuple f = parens $ sep $ punctuate comma $ map f vars
     con s = text s <> char '_' <> int n
     tuple f = parens $ hsep $ punctuate comma $ map f vars
     vtuple f = parens $ sep $ punctuate comma $ map f vars
     con s = text s <> char '_' <> int n
+    var c = text (c : "_")
 
     data_instance ty c
       = hang (hsep [text "data instance", text ty, tuple id])
 
     data_instance ty c
       = hang (hsep [text "data instance", text ty, tuple id])
@@ -39,17 +40,17 @@ generate n =
                         <+> text "=>" <+> text cls <+> tuple id
 
 
                         <+> text "=>" <+> text cls <+> tuple id
 
 
-    pat c = parens $ con c <+> char 'n' <+> sep varss
-    patn c n = parens $ con c <+> (char 'n' <> int n)
+    pat c = parens $ con c <+> var 'n' <+> sep varss
+    patn c n = parens $ con c <+> (var 'n' <> int n)
                               <+> sep [v <> int n | v <- varss]
 
                               <+> sep [v <> int n | v <- varss]
 
-    gen_length c = (pat c, char 'n')
+    gen_length c = (pat c, var 'n')
 
     gen_unsafeSlice mod c
 
     gen_unsafeSlice mod c
-      = (pat c <+> char 'i' <+> char 'm',
-         con c <+> char 'm'
+      = (pat c <+> var 'i' <+> var 'm',
+         con c <+> var 'm'
                <+> vcat [parens $ text mod <> char '.' <> text "unsafeSlice"
                <+> vcat [parens $ text mod <> char '.' <> text "unsafeSlice"
-                                  <+> vs <+> char 'i' <+> char 'm'
+                                  <+> vs <+> var 'i' <+> var 'm'
                                         | vs <- varss])
 
 
                                         | vs <- varss])
 
 
@@ -57,28 +58,28 @@ generate n =
                     vcat $ r : [text "||" <+> r | r <- rs])
       where
         r : rs = [text "M.overlaps" <+> v <> char '1' <+> v <> char '2'
                     vcat $ r : [text "||" <+> r | r <- rs])
       where
         r : rs = [text "M.overlaps" <+> v <> char '1' <+> v <> char '2'
-                        | v <- vars]
+                        | v <- varss]
 
     gen_unsafeNew
 
     gen_unsafeNew
-      = (char 'n',
-         mk_do [v <+> text "<- M.unsafeNew n" | v <- varss]
-               $ text "return $" <+> con "MV" <+> sep varss)
+      = (var 'n',
+         mk_do [v <+> text "<- M.unsafeNew" <+> var 'n' | v <- varss]
+               $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
 
     gen_unsafeNewWith
 
     gen_unsafeNewWith
-      = (char 'n' <+> tuple id,
-         mk_do [vs <+> text "<- M.unsafeNewWith n" <+> v | v  <- vars
-                                                         | vs <- varss]
-               $ text "return $" <+> con "MV" <+> sep varss)
+      = (var 'n' <+> tuple id,
+         mk_do [vs <+> text "<- M.unsafeNewWith" <+> var 'n' <+> v
+                        | v  <- vars | vs <- varss]
+               $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
 
     gen_unsafeRead
 
     gen_unsafeRead
-      = (pat "MV" <+> char 'i',
-         mk_do [v <+> text "<- M.unsafeRead" <+> vs <+> char 'i' | v  <- vars
-                                                                 | vs <- varss]
+      = (pat "MV" <+> var 'i',
+         mk_do [v <+> text "<- M.unsafeRead" <+> vs <+> var 'i' | v  <- vars
+                                                                | vs <- varss]
                $ text "return" <+> tuple id)
 
     gen_unsafeWrite
                $ text "return" <+> tuple id)
 
     gen_unsafeWrite
-      = (pat "MV" <+> char 'i' <+> tuple id,
-         mk_do [text "M.unsafeWrite" <+> vs <+> char 'i' <+> v | v  <- vars
+      = (pat "MV" <+> var 'i' <+> tuple id,
+         mk_do [text "M.unsafeWrite" <+> vs <+> var 'i' <+> v | v  <- vars
                                                                | vs <- varss]
                empty)
 
                                                                | vs <- varss]
                empty)
 
@@ -95,21 +96,22 @@ generate n =
                         | vs <- varss] empty)
 
     gen_unsafeGrow
                         | vs <- varss] empty)
 
     gen_unsafeGrow
-      = (pat "MV" <+> char 'm',
-         mk_do [text "M.unsafeGrow" <+> vs <+> char 'm' | vs <- varss]
-               $ text "return $" <+> con "MV" <+> text "(m+n)"
+      = (pat "MV" <+> var 'm',
+         mk_do [text "M.unsafeGrow" <+> vs <+> var 'm' | vs <- varss]
+               $ text "return $" <+> con "MV"
+                                 <+> parens (var 'm' <> char '+' <> var 'n')
                                  <+> sep varss)
 
     gen_unsafeFreeze
       = (pat "MV",
          mk_do [vs <> char '\'' <+> text "<- G.unsafeFreeze" <+> vs
                         | vs <- varss]
                                  <+> sep varss)
 
     gen_unsafeFreeze
       = (pat "MV",
          mk_do [vs <> char '\'' <+> text "<- G.unsafeFreeze" <+> vs
                         | vs <- varss]
-               $ text "return $" <+> con "V" <+> char 'n'
+               $ text "return $" <+> con "V" <+> var 'n'
                                  <+> sep [vs <> char '\'' | vs <- varss])
 
     gen_basicUnsafeIndexM
                                  <+> sep [vs <> char '\'' | vs <- varss])
 
     gen_basicUnsafeIndexM
-      = (pat "V" <+> char 'i',
-         mk_do [v <+> text "<- G.basicUnsafeIndexM" <+> vs <+> char 'i'
+      = (pat "V" <+> var 'i',
+         mk_do [v <+> text "<- G.basicUnsafeIndexM" <+> vs <+> var 'i'
                         | vs <- varss | v <- vars]
                $ text "return" <+> tuple id)
 
                         | vs <- varss | v <- vars]
                $ text "return" <+> tuple id)
 
@@ -140,5 +142,5 @@ generate n =
 
     methods_Vector  = [("unsafeFreeze",      gen_unsafeFreeze)
                       ,("basicLength",       gen_length "V")
 
     methods_Vector  = [("unsafeFreeze",      gen_unsafeFreeze)
                       ,("basicLength",       gen_length "V")
-                      ,("unsafeSlice",       gen_unsafeSlice "G" "V")
+                      ,("basicUnsafeSlice",       gen_unsafeSlice "G" "V")
                       ,("basicUnsafeIndexM", gen_basicUnsafeIndexM)]
                       ,("basicUnsafeIndexM", gen_basicUnsafeIndexM)]
diff --git a/internal/unbox-tuple-instances b/internal/unbox-tuple-instances
new file mode 100644 (file)
index 0000000..48917ec
--- /dev/null
@@ -0,0 +1,2120 @@
+data instance MVector s (a, b)
+    = MV_2 {-# UNPACK #-} !Int (MVector s a)
+                               (MVector s b)
+data instance Vector (a, 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_
+          return $ MV_2 n_ as bs
+  {-# INLINE unsafeNewWith  #-}
+  unsafeNewWith n_ (a, b)
+      = do
+          as <- M.unsafeNewWith n_ a
+          bs <- M.unsafeNewWith n_ b
+          return $ MV_2 n_ as bs
+  {-# INLINE unsafeRead  #-}
+  unsafeRead (MV_2 n_ as bs) i_
+      = do
+          a <- M.unsafeRead as i_
+          b <- M.unsafeRead 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
+instance (Unbox a, Unbox b) => G.Vector Vector (a, b) where
+  {-# INLINE unsafeFreeze  #-}
+  unsafeFreeze (MV_2 n_ as bs)
+      = do
+          as' <- G.unsafeFreeze as
+          bs' <- G.unsafeFreeze bs
+          return $ V_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_)
+  {-# INLINE basicUnsafeIndexM  #-}
+  basicUnsafeIndexM (V_2 n_ as bs) i_
+      = do
+          a <- G.basicUnsafeIndexM as i_
+          b <- G.basicUnsafeIndexM bs i_
+          return (a, b)
+data instance MVector s (a, b, 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)
+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_
+          return $ MV_3 n_ as bs cs
+  {-# INLINE unsafeNewWith  #-}
+  unsafeNewWith n_ (a, b, c)
+      = do
+          as <- M.unsafeNewWith n_ a
+          bs <- M.unsafeNewWith n_ b
+          cs <- M.unsafeNewWith n_ c
+          return $ MV_3 n_ as bs cs
+  {-# INLINE unsafeRead  #-}
+  unsafeRead (MV_3 n_ as bs cs) i_
+      = do
+          a <- M.unsafeRead as i_
+          b <- M.unsafeRead bs i_
+          c <- M.unsafeRead 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
+instance (Unbox a,
+          Unbox b,
+          Unbox c) => G.Vector Vector (a, b, c) where
+  {-# INLINE unsafeFreeze  #-}
+  unsafeFreeze (MV_3 n_ as bs cs)
+      = do
+          as' <- G.unsafeFreeze as
+          bs' <- G.unsafeFreeze bs
+          cs' <- G.unsafeFreeze cs
+          return $ V_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_)
+  {-# INLINE basicUnsafeIndexM  #-}
+  basicUnsafeIndexM (V_3 n_ as bs cs) i_
+      = do
+          a <- G.basicUnsafeIndexM as i_
+          b <- G.basicUnsafeIndexM bs i_
+          c <- G.basicUnsafeIndexM cs i_
+          return (a, b, c)
+data instance MVector s (a, b, c, 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)
+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_
+          return $ MV_4 n_ as bs cs ds
+  {-# INLINE unsafeNewWith  #-}
+  unsafeNewWith 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
+          return $ MV_4 n_ as bs cs ds
+  {-# INLINE unsafeRead  #-}
+  unsafeRead (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_
+          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
+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)
+      = do
+          as' <- G.unsafeFreeze as
+          bs' <- G.unsafeFreeze bs
+          cs' <- G.unsafeFreeze cs
+          ds' <- G.unsafeFreeze ds
+          return $ V_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_)
+  {-# INLINE basicUnsafeIndexM  #-}
+  basicUnsafeIndexM (V_4 n_ as bs cs ds) i_
+      = do
+          a <- G.basicUnsafeIndexM as i_
+          b <- G.basicUnsafeIndexM bs i_
+          c <- G.basicUnsafeIndexM cs i_
+          d <- G.basicUnsafeIndexM ds i_
+          return (a, b, c, d)
+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)
+data instance Vector (a, b, c, d, e)
+    = V_5 {-# UNPACK #-} !Int (Vector a)
+                              (Vector b)
+                              (Vector c)
+                              (Vector d)
+                              (Vector e)
+instance (Unbox a,
+          Unbox b,
+          Unbox c,
+          Unbox d,
+          Unbox e) => Unbox (a, b, c, d, e)
+instance (Unbox a,
+          Unbox b,
+          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_
+          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
+          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_
+          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
+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
+          return $ V_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_)
+  {-# INLINE basicUnsafeIndexM  #-}
+  basicUnsafeIndexM (V_5 n_ as bs cs ds es) 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_
+          return (a, b, c, d, e)
+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)
+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)
+instance (Unbox a,
+          Unbox b,
+          Unbox c,
+          Unbox d,
+          Unbox e,
+          Unbox f) => Unbox (a, b, c, d, e, f)
+instance (Unbox a,
+          Unbox b,
+          Unbox c,
+          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_
+          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
+          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_
+          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
+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
+          return $ V_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_)
+  {-# INLINE basicUnsafeIndexM  #-}
+  basicUnsafeIndexM (V_6 n_ as bs cs ds es fs) 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_
+          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
+                                                              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)
index 1198260..07fe554 100644 (file)
@@ -37,6 +37,8 @@ Extra-Source-Files:
       tests/Utilities.hs
       tests/Tests/Stream.hs
       tests/Tests/Vector.hs
       tests/Utilities.hs
       tests/Tests/Stream.hs
       tests/Tests/Vector.hs
+      internal/GenUnboxTuple.hs
+      internal/unbox-tuple-instances
 
 Flag BoundsChecks
   Description: Enable bounds checking
 
 Flag BoundsChecks
   Description: Enable bounds checking
@@ -80,7 +82,7 @@ Library
         Data.Vector
 
   Include-Dirs:
         Data.Vector
 
   Include-Dirs:
-        include
+        include, internal
 
   Install-Includes:
         vector.h
 
   Install-Includes:
         vector.h