about summary refs log tree commit diff
path: root/third_party/bazel/rules_haskell/examples/vector/internal
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/bazel/rules_haskell/examples/vector/internal')
-rw-r--r--third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs239
-rw-r--r--third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances1134
2 files changed, 0 insertions, 1373 deletions
diff --git a/third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs b/third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs
deleted file mode 100644
index 8debff23a975..000000000000
--- a/third_party/bazel/rules_haskell/examples/vector/internal/GenUnboxTuple.hs
+++ /dev/null
@@ -1,239 +0,0 @@
-{-# LANGUAGE ParallelListComp #-}
-module Main where
-
-import Text.PrettyPrint
-
-import System.Environment ( getArgs )
-
-main = do
-         [s] <- getArgs
-         let n = read s
-         mapM_ (putStrLn . render . generate) [2..n]
-
-generate :: Int -> Doc
-generate n =
-  vcat [ text "#ifdef DEFINE_INSTANCES"
-       , data_instance "MVector s" "MV"
-       , data_instance "Vector" "V"
-       , class_instance "Unbox"
-       , class_instance "M.MVector MVector" <+> text "where"
-       , nest 2 $ vcat $ map method methods_MVector
-       , class_instance "G.Vector Vector" <+> text "where"
-       , nest 2 $ vcat $ map method methods_Vector
-       , text "#endif"
-       , text "#ifdef DEFINE_MUTABLE"
-       , define_zip "MVector s" "MV"
-       , define_unzip "MVector s" "MV"
-       , text "#endif"
-       , text "#ifdef DEFINE_IMMUTABLE"
-       , define_zip "Vector" "V"
-       , define_zip_rule
-       , define_unzip "Vector" "V"
-       , text "#endif"
-       ]
-
-  where
-    vars  = map (\c -> text ['_',c]) $ take n ['a'..]
-    varss = map (<> char 's') vars
-    tuple xs = parens $ hsep $ punctuate comma xs
-    vtuple xs = parens $ sep $ punctuate comma xs
-    con s = text s <> char '_' <> int n
-    var c = text ('_' : c : "_")
-
-    data_instance ty c
-      = hang (hsep [text "data instance", text ty, tuple vars])
-             4
-             (hsep [char '=', con c, text "{-# UNPACK #-} !Int"
-                   , vcat $ map (\v -> char '!' <> parens (text ty <+> v)) vars])
-
-    class_instance cls
-      = text "instance" <+> vtuple [text "Unbox" <+> v | v <- vars]
-                        <+> text "=>" <+> text cls <+> tuple vars
-
-
-    define_zip ty c
-      = sep [text "-- | /O(1)/ Zip" <+> int n <+> text "vectors"
-            ,name <+> text "::"
-                  <+> vtuple [text "Unbox" <+> v | v <- vars]
-                  <+> text "=>"
-                  <+> sep (punctuate (text " ->") [text ty <+> v | v <- vars])
-                  <+> text "->"
-                  <+> text ty <+> tuple vars
-             ,text "{-# INLINE_FUSED"  <+> name <+> text "#-}"
-             ,name <+> sep varss
-                   <+> text "="
-                   <+> con c
-                   <+> text "len"
-                   <+> sep [parens $ text "unsafeSlice"
-                                     <+> char '0'
-                                     <+> text "len"
-                                     <+> vs | vs <- varss]
-             ,nest 2 $ hang (text "where")
-                            2
-                     $ text "len ="
-                       <+> sep (punctuate (text " `delayed_min`")
-                                          [text "length" <+> vs | vs <- varss])
-             ]
-      where
-        name | n == 2    = text "zip"
-             | otherwise = text "zip" <> int n
-
-    define_zip_rule
-      = hang (text "{-# RULES" <+> text "\"stream/" <> name "zip"
-              <> text " [Vector.Unboxed]\" forall" <+> sep varss <+> char '.')
-             2 $
-             text "G.stream" <+> parens (name "zip" <+> sep varss)
-             <+> char '='
-             <+> text "Bundle." <> name "zipWith" <+> tuple (replicate n empty)
-             <+> sep [parens $ text "G.stream" <+> vs | vs <- varss]
-             $$ text "#-}"
-     where
-       name s | n == 2    = text s
-              | otherwise = text s <> int n
-       
-
-    define_unzip ty c
-      = sep [text "-- | /O(1)/ Unzip" <+> int n <+> text "vectors"
-            ,name <+> text "::"
-                  <+> vtuple [text "Unbox" <+> v | v <- vars]
-                  <+> text "=>"
-                  <+> text ty <+> tuple vars
-                  <+> text "->" <+> vtuple [text ty <+> v | v <- vars]
-            ,text "{-# INLINE" <+> name <+> text "#-}"
-            ,name <+> pat c <+> text "="
-                  <+> vtuple varss
-            ]
-      where
-        name | n == 2    = text "unzip"
-             | otherwise = text "unzip" <> 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]
-
-    qM s = text "M." <> text s
-    qG s = text "G." <> text s
-
-    gen_length c _ = (pat c, var 'n')
-
-    gen_unsafeSlice mod c rec
-      = (var 'i' <+> var 'm' <+> pat c,
-         con c <+> var 'm'
-               <+> vcat [parens
-                         $ text mod <> char '.' <> text rec
-                                    <+> var 'i' <+> var 'm' <+> vs
-                                        | vs <- varss])
-
-
-    gen_overlaps rec = (patn "MV" 1 <+> patn "MV" 2,
-                        vcat $ r : [text "||" <+> r | r <- rs])
-      where
-        r : rs = [qM rec <+> v <> char '1' <+> v <> char '2' | v <- varss]
-
-    gen_unsafeNew rec
-      = (var 'n',
-         mk_do [v <+> text "<-" <+> qM rec <+> var 'n' | v <- varss]
-               $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
-
-    gen_unsafeReplicate rec
-      = (var 'n' <+> tuple vars,
-         mk_do [vs <+> text "<-" <+> qM rec <+> var 'n' <+> v
-                        | v  <- vars | vs <- varss]
-               $ text "return $" <+> con "MV" <+> var 'n' <+> sep varss)
-
-    gen_unsafeRead rec
-      = (pat "MV" <+> var 'i',
-         mk_do [v <+> text "<-" <+> qM rec <+> vs <+> var 'i' | v  <- vars
-                                                              | vs <- varss]
-               $ text "return" <+> tuple vars)
-
-    gen_unsafeWrite rec
-      = (pat "MV" <+> var 'i' <+> tuple vars,
-         mk_do [qM rec <+> vs <+> var 'i' <+> v | v  <- vars | vs <- varss]
-               empty)
-
-    gen_clear rec
-      = (pat "MV", mk_do [qM rec <+> vs | vs <- varss] empty)
-
-    gen_set rec
-      = (pat "MV" <+> tuple vars,
-         mk_do [qM rec <+> vs <+> v | vs <- varss | v <- vars] empty)
-
-    gen_unsafeCopy c q rec
-      = (patn "MV" 1 <+> patn c 2,
-         mk_do [q rec <+> vs <> char '1' <+> vs <> char '2' | vs <- varss]
-               empty)
-
-    gen_unsafeMove rec
-      = (patn "MV" 1 <+> patn "MV" 2,
-         mk_do [qM rec <+> vs <> char '1' <+> vs <> char '2' | vs <- varss]
-               empty)
-
-    gen_unsafeGrow rec
-      = (pat "MV" <+> var 'm',
-         mk_do [vs <> char '\'' <+> text "<-"
-                                <+> qM rec <+> vs <+> var 'm' | vs <- varss]
-               $ text "return $" <+> con "MV"
-                                 <+> parens (var 'm' <> char '+' <> var 'n')
-                                 <+> sep (map (<> char '\'') varss))
-
-    gen_initialize rec
-      = (pat "MV", mk_do [qM rec <+> vs | vs <- varss] empty)
-
-    gen_unsafeFreeze rec
-      = (pat "MV",
-         mk_do [vs <> char '\'' <+> text "<-" <+> qG rec <+> vs | vs <- varss]
-               $ text "return $" <+> con "V" <+> var 'n'
-                                 <+> sep [vs <> char '\'' | vs <- varss])
-
-    gen_unsafeThaw rec
-      = (pat "V",
-         mk_do [vs <> char '\'' <+> text "<-" <+> qG rec <+> vs | vs <- varss]
-               $ text "return $" <+> con "MV" <+> var 'n'
-                                 <+> sep [vs <> char '\'' | vs <- varss])
-
-    gen_basicUnsafeIndexM rec
-      = (pat "V" <+> var 'i',
-         mk_do [v <+> text "<-" <+> qG rec <+> vs <+> var 'i'
-                        | vs <- varss | v <- vars]
-               $ text "return" <+> tuple vars)
-
-    gen_elemseq rec
-      = (char '_' <+> tuple vars,
-         vcat $ r : [char '.' <+> r | r <- rs])
-      where
-        r : rs = [qG rec <+> parens (text "undefined :: Vector" <+> v)
-                         <+> v | v <- vars]
-
-    mk_do cmds ret = hang (text "do")
-                          2
-                          $ vcat $ cmds ++ [ret]
-
-    method (s, f) = case f s of
-                      (p,e) ->  text "{-# INLINE" <+> text s <+> text " #-}"
-                                $$ hang (text s <+> p)
-                                   4
-                                   (char '=' <+> e)
-                             
-
-    methods_MVector = [("basicLength",            gen_length "MV")
-                      ,("basicUnsafeSlice",       gen_unsafeSlice "M" "MV")
-                      ,("basicOverlaps",          gen_overlaps)
-                      ,("basicUnsafeNew",         gen_unsafeNew)
-                      ,("basicUnsafeReplicate",   gen_unsafeReplicate)
-                      ,("basicUnsafeRead",        gen_unsafeRead)
-                      ,("basicUnsafeWrite",       gen_unsafeWrite)
-                      ,("basicClear",             gen_clear)
-                      ,("basicSet",               gen_set)
-                      ,("basicUnsafeCopy",        gen_unsafeCopy "MV" qM)
-                      ,("basicUnsafeMove",        gen_unsafeMove)
-                      ,("basicUnsafeGrow",        gen_unsafeGrow)
-                      ,("basicInitialize",        gen_initialize)]
-
-    methods_Vector  = [("basicUnsafeFreeze",      gen_unsafeFreeze)
-                      ,("basicUnsafeThaw",        gen_unsafeThaw)
-                      ,("basicLength",            gen_length "V")
-                      ,("basicUnsafeSlice",       gen_unsafeSlice "G" "V")
-                      ,("basicUnsafeIndexM",      gen_basicUnsafeIndexM)
-                      ,("basicUnsafeCopy",        gen_unsafeCopy "V" qG)
-                      ,("elemseq",                gen_elemseq)]
diff --git a/third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances b/third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances
deleted file mode 100644
index 6fb88d4a4047..000000000000
--- a/third_party/bazel/rules_haskell/examples/vector/internal/unbox-tuple-instances
+++ /dev/null
@@ -1,1134 +0,0 @@
-#ifdef DEFINE_INSTANCES
-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 basicLength  #-}
-  basicLength (MV_2 n_ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (MV_2 _ as bs)
-      = MV_2 m_ (M.basicUnsafeSlice i_ m_ as)
-                (M.basicUnsafeSlice i_ m_ bs)
-  {-# INLINE basicOverlaps  #-}
-  basicOverlaps (MV_2 _ as1 bs1) (MV_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 basicInitialize  #-}
-  basicInitialize (MV_2 _ as bs)
-      = do
-          M.basicInitialize as
-          M.basicInitialize bs
-  {-# INLINE basicUnsafeReplicate  #-}
-  basicUnsafeReplicate n_ (a, b)
-      = do
-          as <- M.basicUnsafeReplicate n_ a
-          bs <- M.basicUnsafeReplicate n_ b
-          return $ MV_2 n_ as bs
-  {-# INLINE basicUnsafeRead  #-}
-  basicUnsafeRead (MV_2 _ as bs) i_
-      = do
-          a <- M.basicUnsafeRead as i_
-          b <- M.basicUnsafeRead bs i_
-          return (a, b)
-  {-# INLINE basicUnsafeWrite  #-}
-  basicUnsafeWrite (MV_2 _ as bs) i_ (a, b)
-      = do
-          M.basicUnsafeWrite as i_ a
-          M.basicUnsafeWrite bs i_ b
-  {-# INLINE basicClear  #-}
-  basicClear (MV_2 _ as bs)
-      = do
-          M.basicClear as
-          M.basicClear bs
-  {-# INLINE basicSet  #-}
-  basicSet (MV_2 _ as bs) (a, b)
-      = do
-          M.basicSet as a
-          M.basicSet bs b
-  {-# INLINE basicUnsafeCopy  #-}
-  basicUnsafeCopy (MV_2 _ as1 bs1) (MV_2 _ as2 bs2)
-      = do
-          M.basicUnsafeCopy as1 as2
-          M.basicUnsafeCopy bs1 bs2
-  {-# INLINE basicUnsafeMove  #-}
-  basicUnsafeMove (MV_2 _ as1 bs1) (MV_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 basicUnsafeFreeze  #-}
-  basicUnsafeFreeze (MV_2 n_ as bs)
-      = do
-          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_ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (V_2 _ as bs)
-      = V_2 m_ (G.basicUnsafeSlice i_ m_ as)
-               (G.basicUnsafeSlice i_ m_ bs)
-  {-# INLINE basicUnsafeIndexM  #-}
-  basicUnsafeIndexM (V_2 _ as bs) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          return (a, b)
-  {-# INLINE basicUnsafeCopy  #-}
-  basicUnsafeCopy (MV_2 _ as1 bs1) (V_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 _ 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) = Bundle.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 _ 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)
-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 basicLength  #-}
-  basicLength (MV_3 n_ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (MV_3 _ 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 _ as1 bs1 cs1) (MV_3 _ 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 basicInitialize #-}
-  basicInitialize (MV_3 _ as bs cs)
-      = do
-          M.basicInitialize as
-          M.basicInitialize bs
-          M.basicInitialize cs
-  {-# INLINE basicUnsafeReplicate  #-}
-  basicUnsafeReplicate n_ (a, b, c)
-      = do
-          as <- M.basicUnsafeReplicate n_ a
-          bs <- M.basicUnsafeReplicate n_ b
-          cs <- M.basicUnsafeReplicate n_ c
-          return $ MV_3 n_ as bs cs
-  {-# INLINE basicUnsafeRead  #-}
-  basicUnsafeRead (MV_3 _ as bs cs) i_
-      = do
-          a <- M.basicUnsafeRead as i_
-          b <- M.basicUnsafeRead bs i_
-          c <- M.basicUnsafeRead cs i_
-          return (a, b, c)
-  {-# INLINE basicUnsafeWrite  #-}
-  basicUnsafeWrite (MV_3 _ 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 _ as bs cs)
-      = do
-          M.basicClear as
-          M.basicClear bs
-          M.basicClear cs
-  {-# INLINE basicSet  #-}
-  basicSet (MV_3 _ as bs cs) (a, b, c)
-      = do
-          M.basicSet as a
-          M.basicSet bs b
-          M.basicSet cs c
-  {-# INLINE basicUnsafeCopy  #-}
-  basicUnsafeCopy (MV_3 _ as1 bs1 cs1) (MV_3 _ as2 bs2 cs2)
-      = do
-          M.basicUnsafeCopy as1 as2
-          M.basicUnsafeCopy bs1 bs2
-          M.basicUnsafeCopy cs1 cs2
-  {-# INLINE basicUnsafeMove  #-}
-  basicUnsafeMove (MV_3 _ as1 bs1 cs1) (MV_3 _ 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 basicUnsafeFreeze  #-}
-  basicUnsafeFreeze (MV_3 n_ as bs cs)
-      = do
-          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_ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (V_3 _ 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 _ as bs cs) i_
-      = do
-          a <- G.basicUnsafeIndexM as i_
-          b <- G.basicUnsafeIndexM bs i_
-          c <- G.basicUnsafeIndexM cs i_
-          return (a, b, c)
-  {-# INLINE basicUnsafeCopy  #-}
-  basicUnsafeCopy (MV_3 _ as1 bs1 cs1) (V_3 _ 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 _ 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) = Bundle.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 _ 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)
-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 basicLength  #-}
-  basicLength (MV_4 n_ _ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (MV_4 _ 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 _ as1 bs1 cs1 ds1) (MV_4 _ 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 basicInitialize #-}
-  basicInitialize (MV_4 _ as bs cs ds)
-      = do
-          M.basicInitialize as
-          M.basicInitialize bs
-          M.basicInitialize cs
-          M.basicInitialize ds
-  {-# INLINE basicUnsafeReplicate  #-}
-  basicUnsafeReplicate n_ (a, b, c, d)
-      = do
-          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 basicUnsafeRead  #-}
-  basicUnsafeRead (MV_4 _ as bs cs ds) i_
-      = do
-          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 basicUnsafeWrite  #-}
-  basicUnsafeWrite (MV_4 _ 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 _ as bs cs ds)
-      = do
-          M.basicClear as
-          M.basicClear bs
-          M.basicClear cs
-          M.basicClear ds
-  {-# INLINE basicSet  #-}
-  basicSet (MV_4 _ 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 _ as1 bs1 cs1 ds1) (MV_4 _ 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 _ as1 bs1 cs1 ds1) (MV_4 _ 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 basicUnsafeFreeze  #-}
-  basicUnsafeFreeze (MV_4 n_ as bs cs ds)
-      = do
-          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_ _ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (V_4 _ 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 _ 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)
-  {-# INLINE basicUnsafeCopy  #-}
-  basicUnsafeCopy (MV_4 _ as1 bs1 cs1 ds1) (V_4 _ 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 _ 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) = Bundle.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 _ 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)
-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 basicLength  #-}
-  basicLength (MV_5 n_ _ _ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (MV_5 _ 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 _ as1 bs1 cs1 ds1 es1) (MV_5 _ 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 basicInitialize #-}
-  basicInitialize (MV_5 _ as bs cs ds es)
-      = do
-          M.basicInitialize as
-          M.basicInitialize bs
-          M.basicInitialize cs
-          M.basicInitialize ds
-          M.basicInitialize es
-  {-# 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 basicUnsafeRead  #-}
-  basicUnsafeRead (MV_5 _ 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 basicUnsafeWrite  #-}
-  basicUnsafeWrite (MV_5 _ 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 _ 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 _ 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 _ as1 bs1 cs1 ds1 es1) (MV_5 _ 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 _ as1 bs1 cs1 ds1 es1) (MV_5 _ 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 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_ _ _ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (V_5 _ 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 _ 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)
-  {-# INLINE basicUnsafeCopy  #-}
-  basicUnsafeCopy (MV_5 _ as1 bs1 cs1 ds1 es1) (V_5 _ 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 _ 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) = Bundle.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 _ 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)
-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 basicLength  #-}
-  basicLength (MV_6 n_ _ _ _ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (MV_6 _ 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 _ as1 bs1 cs1 ds1 es1 fs1) (MV_6 _ 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 basicInitialize #-}
-  basicInitialize (MV_6 _ as bs cs ds es fs)
-      = do
-          M.basicInitialize as
-          M.basicInitialize bs
-          M.basicInitialize cs
-          M.basicInitialize ds
-          M.basicInitialize es
-          M.basicInitialize fs
-  {-# 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 basicUnsafeRead  #-}
-  basicUnsafeRead (MV_6 _ 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 basicUnsafeWrite  #-}
-  basicUnsafeWrite (MV_6 _ 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 _ 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 _ 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 _ as1 bs1 cs1 ds1 es1 fs1) (MV_6 _ 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 _ as1 bs1 cs1 ds1 es1 fs1) (MV_6 _ 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 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_ _ _ _ _ _ _) = n_
-  {-# INLINE basicUnsafeSlice  #-}
-  basicUnsafeSlice i_ m_ (V_6 _ 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 _ 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)
-  {-# INLINE basicUnsafeCopy  #-}
-  basicUnsafeCopy (MV_6 _ as1 bs1 cs1 ds1 es1 fs1) (V_6 _ as2
-                                                          bs2
-                                                          cs2
-                                                          ds2
-                                                          es2
-                                                          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 _ 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) = Bundle.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 _ as bs cs ds es fs) = (as, bs, cs, ds, es, fs)
-#endif