diff --git a/llvm-extra.cabal b/llvm-extra.cabal
--- a/llvm-extra.cabal
+++ b/llvm-extra.cabal
@@ -1,5 +1,5 @@
 Name:           llvm-extra
-Version:        0.8.1
+Version:        0.8.2
 License:        BSD3
 License-File:   LICENSE
 Author:         Henning Thielemann <haskell@henning-thielemann.de>
@@ -76,7 +76,7 @@
   default:     True
 
 Source-Repository this
-  Tag:         0.8.1
+  Tag:         0.8.2
   Type:        darcs
   Location:    http://code.haskell.org/~thielema/llvm-extra/
 
diff --git a/src/LLVM/Extra/FastMath.hs b/src/LLVM/Extra/FastMath.hs
--- a/src/LLVM/Extra/FastMath.hs
+++ b/src/LLVM/Extra/FastMath.hs
@@ -3,6 +3,7 @@
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
 module LLVM.Extra.FastMath where
 
+import qualified LLVM.Extra.Multi.Vector as MultiVector
 import qualified LLVM.Extra.Multi.Value.Private as MV
 import qualified LLVM.Extra.Arithmetic as A
 import qualified LLVM.Extra.Class as Class
@@ -203,6 +204,147 @@
    (Flags flags, MultiValue a, MV.FloatingComparison a) =>
       MV.FloatingComparison (Number flags a) where
    fcmp p a b = MV.fcmp p (mvDenumber a) (mvDenumber b)
+
+
+
+mvecNumber :: MultiVector.T n a -> MultiVector.T n (Number flags a)
+mvecNumber (MultiVector.Cons v) = MultiVector.Cons v
+
+mvecDenumber :: MultiVector.T n (Number flags a) -> MultiVector.T n a
+mvecDenumber (MultiVector.Cons v) = MultiVector.Cons v
+
+class (MultiValue a, MultiVector.C a) => MultiVector a where
+   setMultiVectorFlags ::
+      (Flags flags, LLVM.Positive n) =>
+      Proxy flags -> Bool ->
+      MultiVector.T n (Number flags a) -> LLVM.CodeGenFunction r ()
+
+instance MultiVector Float where
+   setMultiVectorFlags p b =
+      setFlags p b . MultiVector.deconsPrim . mvecDenumber
+
+instance MultiVector Double where
+   setMultiVectorFlags p b =
+      setFlags p b . MultiVector.deconsPrim . mvecDenumber
+
+attachMultiVectorFlags ::
+   (LLVM.Positive n, Flags flags, MultiVector a) =>
+   Id (LLVM.CodeGenFunction r (MultiVector.T n (Number flags a)))
+attachMultiVectorFlags act = do
+   mv <- act
+   setMultiVectorFlags Proxy True mv
+   return mv
+
+liftMultiVectorM ::
+   (m ~ LLVM.CodeGenFunction r, LLVM.Positive n, Flags flags, MultiVector b) =>
+   (MultiVector.T n a -> m (MultiVector.T n b)) ->
+   MultiVector.T n (Number flags a) -> m (MultiVector.T n (Number flags b))
+liftMultiVectorM f =
+   attachMultiVectorFlags . Monad.lift mvecNumber . f . mvecDenumber
+
+liftMultiVectorM2 ::
+   (m ~ LLVM.CodeGenFunction r, LLVM.Positive n, Flags flags, MultiVector c) =>
+   (MultiVector.T n a -> MultiVector.T n b -> m (MultiVector.T n c)) ->
+   MultiVector.T n (Number flags a) -> MultiVector.T n (Number flags b) ->
+   m (MultiVector.T n (Number flags c))
+liftMultiVectorM2 f a b =
+   attachMultiVectorFlags $
+      Monad.lift mvecNumber $ f (mvecDenumber a) (mvecDenumber b)
+
+instance (Flags flags, MultiVector a) => MultiVector.C (Number flags a) where
+   cons = mvecNumber . MultiVector.cons . fmap deconsNumber
+   undef = mvecNumber MultiVector.undef
+   zero = mvecNumber MultiVector.zero
+   phis bb = fmap mvecNumber . MultiVector.phis bb . mvecDenumber
+   addPhis bb a b = MultiVector.addPhis bb (mvecDenumber a) (mvecDenumber b)
+   shuffle ks a b =
+      fmap mvecNumber $ MultiVector.shuffle ks (mvecDenumber a) (mvecDenumber b)
+   extract k = fmap mvNumber . MultiVector.extract k . mvecDenumber
+   insert k x =
+      fmap mvecNumber . MultiVector.insert k (mvDenumber x) . mvecDenumber
+
+instance
+   (Flags flags,
+    MultiVector a, MV.IntegerConstant a, MultiVector.IntegerConstant a) =>
+      MultiVector.IntegerConstant (Number flags a) where
+   fromInteger' = mvecNumber . MultiVector.fromInteger'
+
+instance
+   (Flags flags,
+    MultiVector a, MV.RationalConstant a, MultiVector.RationalConstant a) =>
+      MultiVector.RationalConstant (Number flags a) where
+   fromRational' = mvecNumber . MultiVector.fromRational'
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Additive a) =>
+      MultiVector.Additive (Number flags a) where
+   add = liftMultiVectorM2 MultiVector.add
+   sub = liftMultiVectorM2 MultiVector.sub
+   neg = liftMultiVectorM MultiVector.neg
+
+instance
+   (Flags flags, MultiVector a, MultiVector.PseudoRing a) =>
+      MultiVector.PseudoRing (Number flags a) where
+   mul = liftMultiVectorM2 MultiVector.mul
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Field a) =>
+      MultiVector.Field (Number flags a) where
+   fdiv = liftMultiVectorM2 MultiVector.fdiv
+
+
+{-
+type instance MultiValue.Scalar (Number flags a) =
+      Number flags (MultiValue.Scalar a)
+instance
+   (Flags flags, MultiVector a, MultiVector.PseudoModule a) =>
+      MultiVector.PseudoModule (Number flags a) where
+   scale = liftMultiVectorM2 MultiVector.mul
+-}
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Real a) =>
+      MultiVector.Real (Number flags a) where
+   min = liftMultiVectorM2 MultiVector.min
+   max = liftMultiVectorM2 MultiVector.max
+   abs = liftMultiVectorM MultiVector.abs
+   signum = liftMultiVectorM MultiVector.signum
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Fraction a) =>
+      MultiVector.Fraction (Number flags a) where
+   truncate = liftMultiVectorM MultiVector.truncate
+   fraction = liftMultiVectorM MultiVector.fraction
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Algebraic a) =>
+      MultiVector.Algebraic (Number flags a) where
+   sqrt = liftMultiVectorM MultiVector.sqrt
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Transcendental a) =>
+      MultiVector.Transcendental (Number flags a) where
+   pi = fmap mvecNumber MultiVector.pi
+   sin = liftMultiVectorM MultiVector.sin
+   cos = liftMultiVectorM MultiVector.cos
+   exp = liftMultiVectorM MultiVector.exp
+   log = liftMultiVectorM MultiVector.log
+   pow = liftMultiVectorM2 MultiVector.pow
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Select a) =>
+      MultiVector.Select (Number flags a) where
+   select = liftMultiVectorM2 . MultiVector.select
+
+instance
+   (Flags flags, MultiVector a, MultiVector.Comparison a) =>
+      MultiVector.Comparison (Number flags a) where
+   cmp p a b = MultiVector.cmp p (mvecDenumber a) (mvecDenumber b)
+
+instance
+   (Flags flags, MultiVector a, MultiVector.FloatingComparison a) =>
+      MultiVector.FloatingComparison (Number flags a) where
+   fcmp p a b = MultiVector.fcmp p (mvecDenumber a) (mvecDenumber b)