diff --git a/contravariant-extras.cabal b/contravariant-extras.cabal
--- a/contravariant-extras.cabal
+++ b/contravariant-extras.cabal
@@ -1,59 +1,36 @@
-name:
-  contravariant-extras
-version:
-  0.3.5
-category:
-  Control
-synopsis:
-  Extras for the "contravariant" package
-homepage:
-  https://github.com/nikita-volkov/contravariant-extras 
-bug-reports:
-  https://github.com/nikita-volkov/contravariant-extras/issues 
-author:
-  Nikita Volkov <nikita.y.volkov@mail.ru>
-maintainer:
-  Nikita Volkov <nikita.y.volkov@mail.ru>
-copyright:
-  (c) 2015, Nikita Volkov
-license:
-  MIT
-license-file:
-  LICENSE
-build-type:
-  Simple
-cabal-version:
-  >=1.10
-
+name: contravariant-extras
+version: 0.3.5.1
+category: Control
+synopsis: Extras for the "contravariant" package
+homepage: https://github.com/nikita-volkov/contravariant-extras
+bug-reports: https://github.com/nikita-volkov/contravariant-extras/issues
+author: Nikita Volkov <nikita.y.volkov@mail.ru>
+maintainer: Nikita Volkov <nikita.y.volkov@mail.ru>
+copyright: (c) 2015, Nikita Volkov
+license: MIT
+license-file: LICENSE
+build-type: Simple
+cabal-version: >=1.10
 
 source-repository head
-  type:
-    git
-  location:
-    git://github.com/nikita-volkov/contravariant-extras.git
-
+  type: git
+  location: git://github.com/nikita-volkov/contravariant-extras.git
 
 library
-  hs-source-dirs:
-    library
-  ghc-options:
-  default-extensions:
-    Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
-  default-language:
-    Haskell2010
-  other-modules:
-    Contravariant.Extras.TH
+  hs-source-dirs: library
+  default-extensions: Arrows, BangPatterns, ConstraintKinds, DataKinds, DefaultSignatures, DeriveDataTypeable, DeriveFoldable, DeriveFunctor, DeriveGeneric, DeriveTraversable, EmptyDataDecls, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, GeneralizedNewtypeDeriving, LambdaCase, LiberalTypeSynonyms, MagicHash, MultiParamTypeClasses, MultiWayIf, NoImplicitPrelude, NoMonomorphismRestriction, OverloadedStrings, PatternGuards, ParallelListComp, QuasiQuotes, RankNTypes, RecordWildCards, ScopedTypeVariables, StandaloneDeriving, TemplateHaskell, TupleSections, TypeFamilies, TypeOperators, UnboxedTuples
+  default-language: Haskell2010
   exposed-modules:
     Contravariant.Extras
     Contravariant.Extras.Contrazip
-    Contravariant.Extras.Eliminate
+    Contravariant.Extras.ContrazipLifting
     Contravariant.Extras.Op
     Contravariant.Extras.Op.Contrazip
+  other-modules:
+    Contravariant.Extras.TH
+    Contravariant.Extras.Prelude
   build-depends:
-    base >= 4 && < 5,
-    tuple-th >= 0.2.5 && < 0.3,
-    template-haskell >= 2.8 && < 3,
-    contravariant >= 1.3 && < 2,
-    base-prelude >= 0.1.19 && < 2,
-    semigroups >= 0.8.4 && < 1
-
+    base >=4.10 && <5,
+    contravariant >=1.3 && <2,
+    template-haskell >=2.8 && <3,
+    template-haskell-compat-v0208 >=0.1.2 && <2
diff --git a/library/Contravariant/Extras.hs b/library/Contravariant/Extras.hs
--- a/library/Contravariant/Extras.hs
+++ b/library/Contravariant/Extras.hs
@@ -1,18 +1,22 @@
 module Contravariant.Extras
 (
-  -- |
-  -- A berserk collection of @contrazip@ functions with arities of up to 42.
+  {-|
+  @contrazip@ functions of multiple arities.
+  -}
   module Contravariant.Extras.Contrazip,
-  module Contravariant.Extras.Eliminate,
+  {-|
+  @contrazipLifting@ functions of multiple arities.
+  -}
+  module Contravariant.Extras.ContrazipLifting,
   (>*<),
   contramany,
   Supplied(..),
 )
 where
 
-import BasePrelude hiding ((<>))
+import Contravariant.Extras.Prelude hiding ((<>))
 import Contravariant.Extras.Contrazip
-import Contravariant.Extras.Eliminate
+import Contravariant.Extras.ContrazipLifting
 import Data.Functor.Contravariant.Divisible
 import Data.Semigroup (Semigroup ((<>)))
 
@@ -46,7 +50,7 @@
 -- A combination of a divisible functor with some input for it.
 -- Allows to use the 'Monoid' API for composition.
 data Supplied divisible =
-  forall input. Supplied !(divisible input) !input
+  forall input. Supplied (divisible input) input
 
 instance Divisible divisible => Semigroup (Supplied divisible) where
   Supplied divisible1 input1 <> Supplied divisible2 input2 =
diff --git a/library/Contravariant/Extras/Contrazip.hs b/library/Contravariant/Extras/Contrazip.hs
--- a/library/Contravariant/Extras/Contrazip.hs
+++ b/library/Contravariant/Extras/Contrazip.hs
@@ -12,7 +12,7 @@
 -- 
 module Contravariant.Extras.Contrazip where
 
-import BasePrelude
+import Contravariant.Extras.Prelude
 import qualified Contravariant.Extras.TH as TH
 
 
diff --git a/library/Contravariant/Extras/ContrazipLifting.hs b/library/Contravariant/Extras/ContrazipLifting.hs
new file mode 100644
--- /dev/null
+++ b/library/Contravariant/Extras/ContrazipLifting.hs
@@ -0,0 +1,34 @@
+module Contravariant.Extras.ContrazipLifting where
+
+import Contravariant.Extras.Prelude
+import Contravariant.Extras.Contrazip
+import Data.Functor.Contravariant.Divisible
+import qualified Contravariant.Extras.TH as TH
+
+
+contrazipLifting2 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> f (a1, a2)
+contrazipLifting2 fn a b = contrazip2 (fn a) (fn b)
+
+contrazipLifting3 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> f (a1, a2, a3)
+contrazipLifting3 fn a b c = contrazip3 (fn a) (fn b) (fn c)
+
+contrazipLifting4 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> f (a1, a2, a3, a4)
+contrazipLifting4 fn a b c d = contrazip4 (fn a) (fn b) (fn c) (fn d)
+
+contrazipLifting5 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> f (a1, a2, a3, a4, a5)
+contrazipLifting5 fn a b c d e = contrazip5 (fn a) (fn b) (fn c) (fn d) (fn e)
+
+contrazipLifting6 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> f (a1, a2, a3, a4, a5, a6)
+contrazipLifting6 fn a b c d e f = contrazip6 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f)
+
+contrazipLifting7 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> f (a1, a2, a3, a4, a5, a6, a7)
+contrazipLifting7 fn a b c d e f g = contrazip7 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g)
+
+contrazipLifting8 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> f (a1, a2, a3, a4, a5, a6, a7, a8)
+contrazipLifting8 fn a b c d e f g h = contrazip8 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g) (fn h)
+
+contrazipLifting9 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> g a9 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9)
+contrazipLifting9 fn a b c d e f g h i = contrazip9 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g) (fn h) (fn i)
+
+contrazipLifting10 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> g a8 -> g a9 -> g a10 -> f (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10)
+contrazipLifting10 fn a b c d e f g h i j = contrazip10 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g) (fn h) (fn i) (fn j)
diff --git a/library/Contravariant/Extras/Eliminate.hs b/library/Contravariant/Extras/Eliminate.hs
deleted file mode 100644
--- a/library/Contravariant/Extras/Eliminate.hs
+++ /dev/null
@@ -1,25 +0,0 @@
-module Contravariant.Extras.Eliminate where
-
-import BasePrelude
-import Contravariant.Extras.Contrazip
-import Data.Functor.Contravariant.Divisible
-import qualified Contravariant.Extras.TH as TH
-
-
-eliminate2 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> f (a1, a2)
-eliminate2 fn a b = contrazip2 (fn a) (fn b)
-
-eliminate3 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> f (a1, a2, a3)
-eliminate3 fn a b c = contrazip3 (fn a) (fn b) (fn c)
-
-eliminate4 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> f (a1, a2, a3, a4)
-eliminate4 fn a b c d = contrazip4 (fn a) (fn b) (fn c) (fn d)
-
-eliminate5 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> f (a1, a2, a3, a4, a5)
-eliminate5 fn a b c d e = contrazip5 (fn a) (fn b) (fn c) (fn d) (fn e)
-
-eliminate6 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> f (a1, a2, a3, a4, a5, a6)
-eliminate6 fn a b c d e f = contrazip6 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f)
-
-eliminate7 :: Divisible f => (forall x. g x -> f x) -> g a1 -> g a2 -> g a3 -> g a4 -> g a5 -> g a6 -> g a7 -> f (a1, a2, a3, a4, a5, a6, a7)
-eliminate7 fn a b c d e f g = contrazip7 (fn a) (fn b) (fn c) (fn d) (fn e) (fn f) (fn g)
diff --git a/library/Contravariant/Extras/Op/Contrazip.hs b/library/Contravariant/Extras/Op/Contrazip.hs
--- a/library/Contravariant/Extras/Op/Contrazip.hs
+++ b/library/Contravariant/Extras/Op/Contrazip.hs
@@ -14,7 +14,7 @@
 -- 
 module Contravariant.Extras.Op.Contrazip where
 
-import BasePrelude
+import Contravariant.Extras.Prelude
 import qualified Contravariant.Extras.TH as TH
 
 
diff --git a/library/Contravariant/Extras/Prelude.hs b/library/Contravariant/Extras/Prelude.hs
new file mode 100644
--- /dev/null
+++ b/library/Contravariant/Extras/Prelude.hs
@@ -0,0 +1,80 @@
+module Contravariant.Extras.Prelude
+( 
+  module Exports,
+)
+where
+
+-- base
+-------------------------
+import Control.Applicative as Exports
+import Control.Arrow as Exports hiding (first, second)
+import Control.Category as Exports
+import Control.Concurrent as Exports
+import Control.Exception as Exports
+import Control.Monad as Exports hiding (fail, mapM_, sequence_, forM_, msum, mapM, sequence, forM)
+import Control.Monad.IO.Class as Exports
+import Control.Monad.Fail as Exports
+import Control.Monad.Fix as Exports hiding (fix)
+import Control.Monad.ST as Exports
+import Data.Bifunctor as Exports
+import Data.Bits as Exports
+import Data.Bool as Exports
+import Data.Char as Exports
+import Data.Coerce as Exports
+import Data.Complex as Exports
+import Data.Data as Exports
+import Data.Dynamic as Exports
+import Data.Either as Exports
+import Data.Fixed as Exports
+import Data.Foldable as Exports hiding (toList)
+import Data.Function as Exports hiding (id, (.))
+import Data.Functor as Exports
+import Data.Functor.Contravariant as Exports
+import Data.Functor.Identity as Exports
+import Data.Int as Exports
+import Data.IORef as Exports
+import Data.Ix as Exports
+import Data.List as Exports hiding (sortOn, isSubsequenceOf, uncons, concat, foldr, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, find, maximumBy, minimumBy, mapAccumL, mapAccumR, foldl')
+import Data.Maybe as Exports
+import Data.Monoid as Exports hiding (Last(..), First(..), (<>))
+import Data.Ord as Exports
+import Data.Proxy as Exports
+import Data.Ratio as Exports
+import Data.Semigroup as Exports
+import Data.STRef as Exports
+import Data.String as Exports
+import Data.Traversable as Exports
+import Data.Tuple as Exports
+import Data.Unique as Exports
+import Data.Version as Exports
+import Data.Void as Exports
+import Data.Word as Exports
+import Debug.Trace as Exports
+import Foreign.ForeignPtr as Exports
+import Foreign.Ptr as Exports
+import Foreign.StablePtr as Exports
+import Foreign.Storable as Exports hiding (sizeOf, alignment)
+import GHC.Conc as Exports hiding (withMVar, threadWaitWriteSTM, threadWaitWrite, threadWaitReadSTM, threadWaitRead)
+import GHC.Exts as Exports (lazy, inline, sortWith, groupWith, IsList(..))
+import GHC.Generics as Exports (Generic, Generic1)
+import GHC.IO.Exception as Exports
+import Numeric as Exports
+import Prelude as Exports hiding (fail, concat, foldr, mapM_, sequence_, foldl1, maximum, minimum, product, sum, all, and, any, concatMap, elem, foldl, foldr1, notElem, or, mapM, sequence, id, (.))
+import System.Environment as Exports
+import System.Exit as Exports
+import System.IO as Exports
+import System.IO.Error as Exports
+import System.IO.Unsafe as Exports
+import System.Mem as Exports
+import System.Mem.StableName as Exports
+import System.Timeout as Exports
+import Text.ParserCombinators.ReadP as Exports (ReadP, ReadS, readP_to_S, readS_to_P)
+import Text.ParserCombinators.ReadPrec as Exports (ReadPrec, readPrec_to_P, readP_to_Prec, readPrec_to_S, readS_to_Prec)
+import Text.Printf as Exports (printf, hPrintf)
+import Text.Read as Exports (Read(..), readMaybe, readEither)
+import Unsafe.Coerce as Exports
+
+-- contravariant
+-------------------------
+import Data.Functor.Contravariant as Exports
+import Data.Functor.Contravariant.Divisible as Exports
diff --git a/library/Contravariant/Extras/TH.hs b/library/Contravariant/Extras/TH.hs
--- a/library/Contravariant/Extras/TH.hs
+++ b/library/Contravariant/Extras/TH.hs
@@ -1,11 +1,11 @@
 {-# LANGUAGE CPP #-}
 module Contravariant.Extras.TH where
 
-import BasePrelude
+import Contravariant.Extras.Prelude
 import Data.Functor.Contravariant
 import Data.Functor.Contravariant.Divisible
-import Language.Haskell.TH hiding (classP)
-import qualified TupleTH
+import Language.Haskell.TH.Syntax hiding (classP)
+import qualified TemplateHaskell.Compat.V0208 as Compat
 
 
 -- |
@@ -208,9 +208,14 @@
 
 splitTupleAtE :: Int -> Int -> Exp
 splitTupleAtE arity position =
-  unsafePerformIO $
-  runQ $
-  TupleTH.splitTupleAt arity position
+  let
+    nameByIndex index = Name (OccName ('_' : show index)) NameS
+    names = enumFromTo 0 (pred arity) & map nameByIndex
+    pats = names & map VarP
+    pat = TupP pats
+    exps = names & map VarE
+    body = splitAt position exps & \ (a, b) -> Compat.tupE [Compat.tupE a, Compat.tupE b]
+    in LamE [pat] body
 
 classP :: Name -> [Type] -> Pred
 #if MIN_VERSION_template_haskell(2,10,0)