diff --git a/Data/Array/Parallel/Lifted/Closure.hs b/Data/Array/Parallel/Lifted/Closure.hs
--- a/Data/Array/Parallel/Lifted/Closure.hs
+++ b/Data/Array/Parallel/Lifted/Closure.hs
@@ -4,7 +4,8 @@
   mkClosure, mkClosureP, ($:), ($:^),
   closure, liftedClosure, liftedApply,
 
-  closure1, closure2, closure3, closure4
+  closure1, closure2, closure3, closure4, closure5,
+  closure6, closure7, closure8
 ) where
 import Data.Array.Parallel.PArray.PReprInstances ()
 import Data.Array.Parallel.PArray.PDataInstances
@@ -76,7 +77,7 @@
 -- | Apply a closure to its argument.
 --
 ($:) :: forall a b. (a :-> b) -> a -> b
-{-# INLINE ($:) #-}
+{-# INLINE [1] ($:) #-}
 Clo f _ e $: a = f e a
 
 {-# RULES
@@ -242,3 +243,123 @@
 
     fv_4 (x, y, z) v = fv x y z v
     fl_4 ps vs = case unzip3PA# ps of (xs, ys, zs) -> fl xs ys zs vs
+
+
+-- | Arity-5 closures.
+closure5 :: (PA a, PA b, PA c, PA d, PA e)
+         => (a -> b -> c -> d -> e -> f)
+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f)
+         -> (a :-> b :-> c :-> d :-> e :-> f)
+
+{-# INLINE closure5 #-}
+closure5 fv fl = mkClosure fv_1 fl_1 ()
+  where
+    fv_1 _  x  = mkClosure  fv_2 fl_2 x
+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs
+
+    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)
+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)
+
+    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)
+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)
+
+    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) 
+    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)
+
+    fv_5 (v, w, x, y) z = fv v w x y z
+    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> fl vs ws xs ys zs
+
+
+-- | Arity-6 closures.
+closure6 :: (PA a, PA b, PA c, PA d, PA e, PA f)
+         => (a -> b -> c -> d -> e -> f -> g)
+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g)
+         -> (a :-> b :-> c :-> d :-> e :-> f :-> g)
+
+{-# INLINE closure6 #-}
+closure6 fv fl = mkClosure fv_1 fl_1 ()
+  where
+    fv_1 _  x  = mkClosure  fv_2 fl_2 x
+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs
+
+    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)
+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)
+
+    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)
+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)
+
+    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) 
+    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)
+
+    fv_5 (v, w, x, y) z = mkClosure fv_6 fl_6 (v, w, x, y, z) 
+    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> mkClosureP fv_6 fl_6  (zip5PA# vs ws xs ys zs)
+
+    fv_6 (u, v, w, x, y) z = fv u v w x y z
+    fl_6 ps zs = case unzip5PA# ps of (us, vs, ws, xs, ys) -> fl us vs ws xs ys zs
+
+-- | Arity-7 closures.
+closure7 :: (PA a, PA b, PA c, PA d, PA e, PA f, PA g)
+         => (a -> b -> c -> d -> e -> f -> g -> h)
+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e 
+         -> PArray f -> PArray g -> PArray h)
+         -> (a :-> b :-> c :-> d :-> e :-> f :-> g :-> h)
+
+{-# INLINE closure7 #-}
+closure7 fv fl = mkClosure fv_1 fl_1 ()
+  where
+    fv_1 _  x  = mkClosure  fv_2 fl_2 x
+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs
+
+    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)
+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)
+
+    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)
+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)
+
+    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) 
+    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)
+
+    fv_5 (v, w, x, y) z = mkClosure fv_6 fl_6 (v, w, x, y, z) 
+    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> mkClosureP fv_6 fl_6  (zip5PA# vs ws xs ys zs)
+
+    fv_6 (u, v, w, x, y) z = mkClosure fv_7 fl_7 (u, v, w, x, y, z) 
+    fl_6 ps zs = case unzip5PA# ps of (us, vs, ws, xs, ys) -> mkClosureP fv_7 fl_7  (zip6PA# us vs ws xs ys zs)
+
+    fv_7 (t, u, v, w, x, y) z = fv t u v w x y z
+    fl_7 ps zs = case unzip6PA# ps of (ts, us, vs, ws, xs, ys) -> fl ts us vs ws xs ys zs
+
+-- | Arity-8 closures.
+closure8 :: (PA a, PA b, PA c, PA d, PA e, PA f, PA g, PA h)
+         => (a -> b -> c -> d -> e -> f -> g -> h -> i)
+         -> (PArray a -> PArray b -> PArray c -> PArray d -> PArray e 
+         -> PArray f -> PArray g -> PArray h -> PArray i)
+         -> (a :-> b :-> c :-> d :-> e :-> f :-> g :-> h :-> i)
+
+{-# INLINE closure8 #-}
+closure8 fv fl = mkClosure fv_1 fl_1 ()
+  where
+    fv_1 _  x  = mkClosure  fv_2 fl_2 x
+    fl_1 _  xs = mkClosureP fv_2 fl_2 xs
+
+    fv_2 x  y  = mkClosure  fv_3 fl_3 (x, y)
+    fl_2 xs ys = mkClosureP fv_3 fl_3 (zipPA# xs ys)
+
+    fv_3 (x, y)  z  = mkClosure  fv_4 fl_4 (x, y, z)
+    fl_3 xys     zs = case unzipPA# xys of (xs, ys) -> mkClosureP fv_4 fl_4 (zip3PA# xs ys zs)
+
+    fv_4 (w, x, y) z = mkClosure fv_5 fl_5 (w, x, y, z) 
+    fl_4 ps zs = case unzip3PA# ps of (ws, xs, ys) -> mkClosureP fv_5 fl_5  (zip4PA# ws xs ys zs)
+
+    fv_5 (v, w, x, y) z = mkClosure fv_6 fl_6 (v, w, x, y, z) 
+    fl_5 ps zs = case unzip4PA# ps of (vs, ws, xs, ys) -> mkClosureP fv_6 fl_6  (zip5PA# vs ws xs ys zs)
+
+    fv_6 (u, v, w, x, y) z = mkClosure fv_7 fl_7 (u, v, w, x, y, z) 
+    fl_6 ps zs = case unzip5PA# ps of (us, vs, ws, xs, ys) -> mkClosureP fv_7 fl_7  (zip6PA# us vs ws xs ys zs)
+
+    fv_7 (t, u, v, w, x, y) z = mkClosure fv_8 fl_8 (t, u, v, w, x, y, z) 
+    fl_7 ps zs = case unzip6PA# ps of (ts, us, vs, ws, xs, ys) -> mkClosureP fv_8 fl_8  (zip7PA# ts us vs ws xs ys zs)
+
+    fv_8 (s, t, u, v, w, x, y) z = fv s t u v w x y z
+    fl_8 ps zs = case unzip7PA# ps of (ss, ts, us, vs, ws, xs, ys) -> fl ss ts us vs ws xs ys zs
+
+   
diff --git a/Data/Array/Parallel/Lifted/Combinators.hs b/Data/Array/Parallel/Lifted/Combinators.hs
--- a/Data/Array/Parallel/Lifted/Combinators.hs
+++ b/Data/Array/Parallel/Lifted/Combinators.hs
@@ -23,7 +23,8 @@
 --
 module Data.Array.Parallel.Lifted.Combinators (
   lengthPA, replicatePA, singletonPA, mapPA, crossMapPA,
-  zipPA, zip3PA, zipWithPA, zipWith3PA, unzipPA, unzip3PA, 
+  zipPA, zip3PA, zip4PA, zipWithPA, zipWith3PA, unzipPA, unzip3PA, unzip4PA ,
+  zipWith4PA,
   packPA, filterPA, combine2PA, indexPA, concatPA, appPA, enumFromToPA_Int,
   indexedPA, slicePA, updatePA, bpermutePA,
 
@@ -191,6 +192,22 @@
   = PArray n# (PNested segd (P_3 xs ys zs))
 
 
+
+zip4PA :: (PA a, PA b, PA c, PA d) => PArray a :-> PArray b :-> PArray c :-> PArray d :-> PArray (a, b, c, d)
+{-# INLINE zip4PA #-}
+zip4PA = closure4 zip4PA_v zip4PA_l
+
+zip4PA_v :: (PA a, PA b, PA c, PA d) => PArray a -> PArray b -> PArray c -> PArray d -> PArray (a, b, c, d)
+{-# INLINE_PA zip4PA_v #-}
+zip4PA_v xs ys = zip4PA# xs ys
+
+zip4PA_l :: (PA a, PA b, PA c, PA d)
+         => PArray (PArray a) -> PArray (PArray b) -> PArray (PArray c) -> PArray (PArray d) -> PArray (PArray (a, b, c, d))
+{-# INLINE_PA zip4PA_l #-}
+zip4PA_l (PArray n# (PNested segd ws)) (PArray _ (PNested _ xs)) (PArray _ (PNested _ ys)) (PArray _ (PNested _ zs))
+  = PArray n# (PNested segd (P_4 ws xs ys zs))
+
+
 -- zipWith --------------------------------------------------------------------
 -- |Map a function over multiple arrays at once.
 
@@ -233,6 +250,26 @@
       (replicatelPA# (segdPA# ass) fs $:^ concatPA# ass $:^ concatPA# bss $:^ concatPA# css)
 
 
+zipWith4PA :: (PA a, PA b, PA c, PA d, PA e)
+           => (a :-> b :-> c :-> d :-> e) :-> PArray a :-> PArray b :-> PArray c :-> PArray d :-> PArray e
+{-# INLINE zipWith4PA #-}
+zipWith4PA = closure5 zipWith4PA_v zipWith4PA_l
+
+zipWith4PA_v :: (PA a, PA b, PA c, PA d, PA e)
+             => (a :-> b :-> c :-> d :-> e) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e
+{-# INLINE_PA zipWith4PA_v #-}
+zipWith4PA_v f as bs cs ds = replicatePA# (lengthPA# as) f $:^ as $:^ bs $:^ cs $:^ ds
+
+zipWith4PA_l :: (PA a, PA b, PA c, PA d, PA e)
+             => PArray (a :-> b :-> c :-> d :-> e) 
+             -> PArray (PArray a) -> PArray (PArray b) -> PArray (PArray c)
+             -> PArray (PArray d) -> PArray (PArray e)
+{-# INLINE_PA zipWith4PA_l #-}
+zipWith4PA_l fs ass bss css dss
+  = copySegdPA# ass
+      (replicatelPA# (segdPA# ass) fs $:^ concatPA# ass $:^ concatPA# bss $:^ concatPA# css $:^ concatPA# dss)
+
+
 -- unzip ----------------------------------------------------------------------
 -- |Transform an array of tuples into a tuple of arrays.
 
@@ -263,6 +300,21 @@
 unzip3PA_l xyzss = zip3PA# (copySegdPA# xyzss xs) (copySegdPA# xyzss ys) (copySegdPA# xyzss zs)
   where
     (xs, ys, zs) = unzip3PA# (concatPA# xyzss)
+
+
+unzip4PA :: (PA a, PA b, PA c, PA d) => PArray (a, b, c, d) :-> (PArray a, PArray b, PArray c, PArray d)
+{-# INLINE unzip4PA #-}
+unzip4PA = closure1 unzip4PA_v unzip4PA_l
+
+unzip4PA_v :: (PA a, PA b, PA c, PA d) => PArray (a, b, c, d) -> (PArray a, PArray b, PArray c, PArray d)
+{-# INLINE_PA unzip4PA_v #-}
+unzip4PA_v abs' = unzip4PA# abs'
+
+unzip4PA_l :: (PA a, PA b, PA c) => PArray (PArray (a, b, c, d)) -> PArray (PArray a, PArray b, PArray c, PArray d)
+{-# INLINE_PA unzip4PA_l #-}
+unzip4PA_l wxyzss = zip4PA# (copySegdPA# wxyzss ws) (copySegdPA# wxyzss xs) (copySegdPA# wxyzss ys) (copySegdPA# wxyzss zs) 
+  where
+    (ws, xs, ys, zs) = unzip4PA# (concatPA# wxyzss) 
 
 
 -- packPA ---------------------------------------------------------------------
diff --git a/Data/Array/Parallel/Lifted/Scalar.hs b/Data/Array/Parallel/Lifted/Scalar.hs
--- a/Data/Array/Parallel/Lifted/Scalar.hs
+++ b/Data/Array/Parallel/Lifted/Scalar.hs
@@ -132,6 +132,64 @@
         $ U.zipWith3 f (toUArray xs) (toUArray ys) (toUArray zs)
 
 
+
+
+-- | Zip four arrays, yielding a new array.
+scalar_zipWith4
+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e)
+        => (a -> b -> c -> d -> e) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e
+
+{-# INLINE_PA scalar_zipWith4 #-}
+scalar_zipWith4 f ws xs ys zs 
+        = fromUArray' (prim_lengthPA ws)
+        $ U.zipWith4 f (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
+
+
+-- | Zip five arrays, yielding a new array.
+scalar_zipWith5
+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f)
+        => (a -> b -> c -> d -> e -> f) -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f
+
+{-# INLINE_PA scalar_zipWith5 #-}
+scalar_zipWith5 f vs ws xs ys zs  
+        = fromUArray' (prim_lengthPA vs)
+        $ U.zipWith5 f (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
+        
+        
+-- | Zip six arrays, yielding a new array.
+scalar_zipWith6
+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g)
+        => (a -> b -> c -> d -> e -> f -> g) 
+        -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray  f-> PArray g
+
+{-# INLINE_PA scalar_zipWith6 #-}
+scalar_zipWith6 f us vs ws xs ys zs 
+        = fromUArray' (prim_lengthPA us)
+        $ U.zipWith6 f (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
+        
+-- | Zip seven arrays, yielding a new array.
+scalar_zipWith7
+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g, Scalar h)
+        => (a -> b -> c -> d -> e -> f -> g -> h) 
+        -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray  f-> PArray g -> PArray h
+
+{-# INLINE_PA scalar_zipWith7 #-}
+scalar_zipWith7 f ts us vs ws xs ys zs 
+        = fromUArray' (prim_lengthPA us)
+        $ U.zipWith7 f (toUArray ts) (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
+                        
+
+-- | Zip eight arrays, yielding a new array.
+scalar_zipWith8
+        :: (Scalar a, Scalar b, Scalar c, Scalar d, Scalar e, Scalar f, Scalar g, Scalar h, Scalar i)
+        => (a -> b -> c -> d -> e -> f -> g -> h -> i) 
+        -> PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray  f-> PArray g -> PArray h -> PArray i
+
+{-# INLINE_PA scalar_zipWith8 #-}
+scalar_zipWith8 f ss ts us vs ws xs ys zs 
+        = fromUArray' (prim_lengthPA ss)
+        $ U.zipWith8 f (toUArray ss)  (toUArray ts) (toUArray us) (toUArray vs) (toUArray ws) (toUArray xs) (toUArray ys) (toUArray zs)
+                        
 -- | Left fold over an array.
 scalar_fold 
         :: Scalar a
diff --git a/Data/Array/Parallel/Lifted/TH/Repr.hs b/Data/Array/Parallel/Lifted/TH/Repr.hs
--- a/Data/Array/Parallel/Lifted/TH/Repr.hs
+++ b/Data/Array/Parallel/Lifted/TH/Repr.hs
@@ -1,4 +1,4 @@
-{-# LANGUAGE TemplateHaskell, Rank2Types #-}
+{-# LANGUAGE TemplateHaskell, RankNTypes #-}
 module Data.Array.Parallel.Lifted.TH.Repr (
   scalarInstances, tupleInstances,
   voidPRInstance, unitPRInstance, wrapPRInstance
@@ -46,7 +46,7 @@
 
 
 inlineD :: Name -> DecQ
-inlineD name = pragInlD name (inlineSpecNoPhase True False)
+inlineD name = pragInlD name Inline FunLike AllPhases
 
 
 instance_PData :: TypeQ -> [Name] -> Name -> [TypeQ] -> DecQ
diff --git a/Data/Array/Parallel/PArray/PDataInstances.hs b/Data/Array/Parallel/PArray/PDataInstances.hs
--- a/Data/Array/Parallel/PArray/PDataInstances.hs
+++ b/Data/Array/Parallel/PArray/PDataInstances.hs
@@ -10,8 +10,9 @@
   punit,
 
   -- * Operators on arrays of tuples
-  zipPA#,  unzipPA#, zip3PA#, unzip3PA#,
-  zip4PA#, zip5PA#, 
+  zipPA#,  unzipPA#, zip3PA#, unzip3PA#, 
+  zip4PA#, unzip4PA#, zip5PA#, unzip5PA#, zip6PA#, unzip6PA#, 
+  zip7PA#, unzip7PA#, zip8PA#, unzip8PA#, 
   
   -- * Operators on nested arrays
   segdPA#, concatPA#, segmentPA#, copySegdPA#
@@ -281,10 +282,53 @@
 zip4PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as)
   = PArray n# (P_4 xs ys zs as)
 
+unzip4PA# :: PArray (a, b, c, d) -> (PArray a, PArray b, PArray c, PArray d)
+{-# INLINE_PA unzip4PA# #-}
+unzip4PA# (PArray n# (P_4 ws xs ys zs))
+   = (PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)
+
 zip5PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray (a, b, c, d, e)
 {-# INLINE_PA zip5PA# #-}
 zip5PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs)
   = PArray n# (P_5 xs ys zs as bs)
+
+unzip5PA# :: PArray (a, b, c, d, e) -> (PArray a, PArray b, PArray c, PArray d, PArray e)
+{-# INLINE_PA unzip5PA# #-}
+unzip5PA# (PArray n# (P_5 vs ws xs ys zs))
+  = (PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)
+
+zip6PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray (a, b, c, d, e, f)
+{-# INLINE_PA zip6PA# #-}
+zip6PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs) (PArray _ cs)
+  = PArray n# (P_6 xs ys zs as bs cs)
+
+unzip6PA# :: PArray (a, b, c, d, e, f) -> (PArray a, PArray b, PArray c, PArray d, PArray e, PArray f)
+{-# INLINE_PA unzip6PA# #-}
+unzip6PA# (PArray n# (P_6 us vs ws xs ys zs))
+  = (PArray n# us, PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)
+
+
+zip7PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g ->
+  PArray (a, b, c, d, e, f, g)
+{-# INLINE_PA zip7PA# #-}
+zip7PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs) (PArray _ cs) (PArray _ ds)
+  = PArray n# (P_7 xs ys zs as bs cs ds)
+
+unzip7PA# :: PArray (a, b, c, d, e, f, g) -> (PArray a, PArray b, PArray c, PArray d, PArray e, PArray f, PArray g)
+{-# INLINE_PA unzip7PA# #-}
+unzip7PA# (PArray n# (P_7 ts us vs ws xs ys zs))
+  = (PArray n# ts, PArray n# us, PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)
+
+zip8PA# :: PArray a -> PArray b -> PArray c -> PArray d -> PArray e -> PArray f -> PArray g -> PArray h ->
+  PArray (a, b, c, d, e, f, g, h)
+{-# INLINE_PA zip8PA# #-}
+zip8PA# (PArray n# xs) (PArray _ ys) (PArray _ zs) (PArray _ as) (PArray _ bs) (PArray _ cs) (PArray _ ds) (PArray _ es)
+  = PArray n# (P_8 xs ys zs as bs cs ds es)
+
+unzip8PA# :: PArray (a, b, c, d, e, f, g, h) -> (PArray a, PArray b, PArray c, PArray d, PArray e, PArray f, PArray g, PArray h)
+{-# INLINE_PA unzip8PA# #-}
+unzip8PA# (PArray n# (P_8 ss ts us vs ws xs ys zs))
+  = (PArray n# ss, PArray n# ts, PArray n# us, PArray n# vs, PArray n# ws, PArray n# xs, PArray n# ys, PArray n# zs)
 
 
 -- Sums -----------------------------------------------------------------------
diff --git a/Data/Array/Parallel/Prim.hs b/Data/Array/Parallel/Prim.hs
--- a/Data/Array/Parallel/Prim.hs
+++ b/Data/Array/Parallel/Prim.hs
@@ -17,11 +17,13 @@
   PData, PDatas(..), PRepr, PA(..), PR(..),
   replicatePD, emptyPD, packByTagPD, combine2PD,
   Scalar(..),
-  scalar_map, scalar_zipWith, scalar_zipWith3,
+  scalar_map, scalar_zipWith, scalar_zipWith3, scalar_zipWith4, scalar_zipWith5, scalar_zipWith6,
+  scalar_zipWith7, scalar_zipWith8,
   Void, Sum2(..), Sum3(..), Wrap(..),
   void, fromVoid, pvoid, pvoids#, punit,
   (:->)(..), 
-  closure, liftedClosure, ($:), liftedApply, closure1, closure2, closure3,
+  closure, liftedClosure, ($:), liftedApply, closure1, closure2, closure3, closure4, 
+  closure5, closure6, closure7, closure8,
   Sel2,  replicateSel2#, tagsSel2, elementsSel2_0#, elementsSel2_1#,
   Sels2, lengthSels2#,
   replicatePA_Int#, replicatePA_Double#,
@@ -45,14 +47,16 @@
 import Data.Array.Parallel.PArray.PData           (PData, PDatas, PR(..))
 import Data.Array.Parallel.PArray.PDataInstances  (pvoid, punit, Sels2)
 import Data.Array.Parallel.Lifted.Closure         ((:->)(..), closure, liftedClosure, ($:),
-                                                   liftedApply, closure1, closure2, closure3)
+                                                   liftedApply, closure1, closure2, closure3, closure4, 
+												   closure5, closure6, closure7, closure8)
 import Data.Array.Parallel.Lifted.Unboxed         (Sel2, replicateSel2#, tagsSel2, elementsSel2_0#,
                                                    elementsSel2_1#,
                                                    replicatePA_Int#, replicatePA_Double#,
                                                    emptyPA_Int#, emptyPA_Double#,
                                                    {- packByTagPA_Int#, packByTagPA_Double# -}
                                                    combine2PA_Int#, combine2PA_Double#)
-import Data.Array.Parallel.Lifted.Scalar          (scalar_map, scalar_zipWith, scalar_zipWith3)
+import Data.Array.Parallel.Lifted.Scalar          (scalar_map, scalar_zipWith, scalar_zipWith3, scalar_zipWith4,
+                                                   scalar_zipWith5, scalar_zipWith6, scalar_zipWith7, scalar_zipWith8)
 import Data.Array.Parallel.Prelude.Tuple          (tup2, tup3, tup4)
 import GHC.Exts
 
diff --git a/dph-lifted-copy.cabal b/dph-lifted-copy.cabal
--- a/dph-lifted-copy.cabal
+++ b/dph-lifted-copy.cabal
@@ -1,5 +1,5 @@
 Name:           dph-lifted-copy
-Version:        0.6.1.1
+Version:        0.7.0.1
 License:        BSD3
 License-File:   LICENSE
 Author:         The DPH Team
@@ -64,11 +64,11 @@
         -fno-warn-missing-signatures
 
   Build-Depends:  
-        base             == 4.5.*,
+        base             == 4.6.*,
         ghc              == 7.*,
         array            == 0.4.*,
         random           == 1.0.*,
-        template-haskell == 2.7.*,
-        vector           == 0.9.*,
-        dph-base         == 0.6.1.*,
-        dph-prim-par     == 0.6.1.*
+        template-haskell == 2.8.*,
+        dph-base         == 0.7.*,
+        dph-prim-par     == 0.7.*,
+        vector           == 0.10.*