diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,13 @@
 
 The format is based on [Keep a Changelog](http://keepachangelog.com/).
 
+## [0.2.0.0] - 2018-10-02
+### Added
+  * Level 3 operations from CUDA-9.2
+  * Format conversion operations from CUDA-9.0
+  * Precondition operations from CUDA-9.0
+  * Precondition operations from CUDA-9.2
+
 ## [0.1.0.1] - 2018-03-12
 ### Fixed
   * Build fix for Cabal-2.2 (ghc-8.4)
@@ -12,5 +19,6 @@
 
   * First version; split off from [bmsherman/cublas](https://github.com/bmsherman/cublas). Released on an unsuspecting world.
 
+[0.2.0.0]:    https://github.com/tmcdonell/cusparse/compare/0.1.0.1...v0.2.0.0
 [0.1.0.1]:    https://github.com/tmcdonell/cusparse/compare/0.1.0.0...0.1.0.1
 
diff --git a/Foreign/CUDA/BLAS/Sparse/Analysis.chs b/Foreign/CUDA/BLAS/Sparse/Analysis.chs
--- a/Foreign/CUDA/BLAS/Sparse/Analysis.chs
+++ b/Foreign/CUDA/BLAS/Sparse/Analysis.chs
@@ -22,8 +22,10 @@
   Info_bsric02(..), createInfo_bsric02, destroyInfo_bsric02,
   Info_bsrilu02(..), createInfo_bsrilu02, destroyInfo_bsrilu02,
   Info_csrgemm2(..), createInfo_csrgemm2, destroyInfo_csrgemm2,
+  Info_csrsm2(..), createInfo_csrsm2, destroyInfo_csrsm2,
   Info_color(..), createInfo_color, destroyInfo_color,
   Info_csru2csr(..), createInfo_csru2csr, destroyInfo_csru2csr,
+  Info_prune(..), createInfo_prune, destroyInfo_prune,
 
 ) where
 
@@ -198,6 +200,34 @@
 #endif
 
 
+-- | <https://docs.nvidia.com/cuda/cusparse/index.html#csrsm2infot>
+--
+#if CUDA_VERSION >= 9020
+newtype Info_csrsm2 = Info_csrsm2 { useInfo_csrsm2 :: {# type csrsm2Info_t #}}
+
+{-# INLINEABLE createInfo_csrsm2 #-}
+{# fun unsafe cusparseCreateCsrsm2Info as createInfo_csrsm2
+  { alloca- `Info_csrsm2' peekI* } -> `()' checkStatus*- #}
+  where
+    peekI = liftM Info_csrsm2 . peek
+
+{-# INLINE destroyInfo_csrsm2 #-}
+{# fun unsafe cusparseDestroyCsrsm2Info as destroyInfo_csrsm2
+  { useInfo_csrsm2 `Info_csrsm2' } -> `()' checkStatus*- #}
+
+#else
+data Info_csrsm2
+
+createInfo_csrsm2 :: IO Info_csrsm2
+createInfo_csrsm2 = cusparseError "'createInfo_csrsm2 requires at least cuda-9.2"
+
+destroyInfo_csrsm2 :: Info_csrsm2 -> IO ()
+destroyInfo_csrsm2 _ = cusparseError "'destroyInfo_csrsm2 requires at least cuda-9.2"
+
+#endif
+
+
+
 -- /undocumented/
 --
 #if CUDA_VERSION >= 7000
@@ -248,6 +278,33 @@
 
 destroyInfo_csru2csr :: Info_csru2csr -> IO ()
 destroyInfo_csru2csr _ = cusparseError "'destroyInfo_csru2csr' requires at least cuda-7.0"
+
+#endif
+
+
+-- /undocumented/
+--
+#if CUDA_VERSION >= 9000
+newtype Info_prune = Info_prune { useInfo_prune :: {# type pruneInfo_t #}}
+
+{-# INLINEABLE createInfo_prune #-}
+{# fun unsafe cusparseCreatePruneInfo as createInfo_prune
+  { alloca- `Info_prune' peekI* } -> `()' checkStatus*- #}
+  where
+    peekI = liftM Info_prune . peek
+
+{-# INLINEABLE destroyInfo_prune #-}
+{# fun unsafe cusparseDestroyPruneInfo as destroyInfo_prune
+  { useInfo_prune `Info_prune' } -> `()' checkStatus* #}
+
+#else
+data Info_prune
+
+createInfo_prune :: IO Info_prune
+createInfo_prune = cusparseError "'createInfo_prune' requires at least cuda-8.0"
+
+destroyInfo_prune :: Info_prune -> IO ()
+destroyInfo_prune _ = cusparseError "'destroyInfo_prune' requires at least cuda-8.0"
 
 #endif
 
diff --git a/Foreign/CUDA/BLAS/Sparse/Convert.chs b/Foreign/CUDA/BLAS/Sparse/Convert.chs
--- a/Foreign/CUDA/BLAS/Sparse/Convert.chs
+++ b/Foreign/CUDA/BLAS/Sparse/Convert.chs
@@ -27,6 +27,7 @@
   Hybrid,
   HybridPartition(..),
   Info_csru2csr,
+  Info_prune,
   sbsr2csr,
   dbsr2csr,
   cbsr2csr,
@@ -141,6 +142,46 @@
   dcsr2csr_compress,
   ccsr2csr_compress,
   zcsr2csr_compress,
+  spruneDense2csr_bufferSizeExt,
+  dpruneDense2csr_bufferSizeExt,
+  hpruneDense2csr_bufferSizeExt,
+  spruneDense2csrNnz,
+  dpruneDense2csrNnz,
+  hpruneDense2csrNnz,
+  spruneDense2csr,
+  dpruneDense2csr,
+  hpruneDense2csr,
+  spruneCsr2csr_bufferSizeExt,
+  dpruneCsr2csr_bufferSizeExt,
+  hpruneCsr2csr_bufferSizeExt,
+  spruneCsr2csrNnz,
+  dpruneCsr2csrNnz,
+  hpruneCsr2csrNnz,
+  spruneCsr2csr,
+  dpruneCsr2csr,
+  hpruneCsr2csr,
+  spruneDense2csrByPercentage_bufferSizeExt,
+  dpruneDense2csrByPercentage_bufferSizeExt,
+  hpruneDense2csrByPercentage_bufferSizeExt,
+  spruneDense2csrNnzByPercentage,
+  dpruneDense2csrNnzByPercentage,
+  hpruneDense2csrNnzByPercentage,
+  spruneDense2csrByPercentage,
+  dpruneDense2csrByPercentage,
+  hpruneDense2csrByPercentage,
+  spruneCsr2csrByPercentage_bufferSizeExt,
+  dpruneCsr2csrByPercentage_bufferSizeExt,
+  hpruneCsr2csrByPercentage_bufferSizeExt,
+  spruneCsr2csrNnzByPercentage,
+  dpruneCsr2csrNnzByPercentage,
+  hpruneCsr2csrNnzByPercentage,
+  spruneCsr2csrByPercentage,
+  dpruneCsr2csrByPercentage,
+  hpruneCsr2csrByPercentage,
+  snnz_compress,
+  dnnz_compress,
+  cnnz_compress,
+  znnz_compress,
 
 ) where
 
@@ -591,4 +632,247 @@
 
 zcsr2csr_compress :: Handle -> Int -> Int -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> DevicePtr Int32 -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> (Complex Double) -> IO ()
 zcsr2csr_compress _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zcsr2csr_compress' requires at least cuda-8.0"
+#endif
+#if CUDA_VERSION >= 9010
+
+{-# INLINEABLE spruneDense2csr_bufferSizeExt #-}
+{# fun unsafe cusparseSpruneDense2csr_bufferSizeExt as spruneDense2csr_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneDense2csr_bufferSizeExt #-}
+{# fun unsafe cusparseDpruneDense2csr_bufferSizeExt as dpruneDense2csr_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneDense2csr_bufferSizeExt #-}
+{# fun unsafe cusparseHpruneDense2csr_bufferSizeExt as hpruneDense2csr_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Half', `Int', castPtr `Ptr Half', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneDense2csrNnz #-}
+{# fun unsafe cusparseSpruneDense2csrNnz as spruneDense2csrNnz { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneDense2csrNnz #-}
+{# fun unsafe cusparseDpruneDense2csrNnz as dpruneDense2csrNnz { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneDense2csrNnz #-}
+{# fun unsafe cusparseHpruneDense2csrNnz as hpruneDense2csrNnz { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Half', `Int', castPtr `Ptr Half', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneDense2csr #-}
+{# fun unsafe cusparseSpruneDense2csr as spruneDense2csr { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneDense2csr #-}
+{# fun unsafe cusparseDpruneDense2csr as dpruneDense2csr { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneDense2csr #-}
+{# fun unsafe cusparseHpruneDense2csr as hpruneDense2csr { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Half', `Int', castPtr `Ptr Half', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneCsr2csr_bufferSizeExt #-}
+{# fun unsafe cusparseSpruneCsr2csr_bufferSizeExt as spruneCsr2csr_bufferSizeExt { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneCsr2csr_bufferSizeExt #-}
+{# fun unsafe cusparseDpruneCsr2csr_bufferSizeExt as dpruneCsr2csr_bufferSizeExt { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneCsr2csr_bufferSizeExt #-}
+{# fun unsafe cusparseHpruneCsr2csr_bufferSizeExt as hpruneCsr2csr_bufferSizeExt { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Half', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneCsr2csrNnz #-}
+{# fun unsafe cusparseSpruneCsr2csrNnz as spruneCsr2csrNnz { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', castPtr `Ptr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneCsr2csrNnz #-}
+{# fun unsafe cusparseDpruneCsr2csrNnz as dpruneCsr2csrNnz { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', castPtr `Ptr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneCsr2csrNnz #-}
+{# fun unsafe cusparseHpruneCsr2csrNnz as hpruneCsr2csrNnz { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Half', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', castPtr `Ptr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneCsr2csr #-}
+{# fun unsafe cusparseSpruneCsr2csr as spruneCsr2csr { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneCsr2csr #-}
+{# fun unsafe cusparseDpruneCsr2csr as dpruneCsr2csr { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneCsr2csr #-}
+{# fun unsafe cusparseHpruneCsr2csr as hpruneCsr2csr { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Half', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneDense2csrByPercentage_bufferSizeExt #-}
+{# fun unsafe cusparseSpruneDense2csrByPercentage_bufferSizeExt as spruneDense2csrByPercentage_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneDense2csrByPercentage_bufferSizeExt #-}
+{# fun unsafe cusparseDpruneDense2csrByPercentage_bufferSizeExt as dpruneDense2csrByPercentage_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneDense2csrByPercentage_bufferSizeExt #-}
+{# fun unsafe cusparseHpruneDense2csrByPercentage_bufferSizeExt as hpruneDense2csrByPercentage_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Half', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneDense2csrNnzByPercentage #-}
+{# fun unsafe cusparseSpruneDense2csrNnzByPercentage as spruneDense2csrNnzByPercentage { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneDense2csrNnzByPercentage #-}
+{# fun unsafe cusparseDpruneDense2csrNnzByPercentage as dpruneDense2csrNnzByPercentage { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneDense2csrNnzByPercentage #-}
+{# fun unsafe cusparseHpruneDense2csrNnzByPercentage as hpruneDense2csrNnzByPercentage { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Half', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneDense2csrByPercentage #-}
+{# fun unsafe cusparseSpruneDense2csrByPercentage as spruneDense2csrByPercentage { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneDense2csrByPercentage #-}
+{# fun unsafe cusparseDpruneDense2csrByPercentage as dpruneDense2csrByPercentage { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneDense2csrByPercentage #-}
+{# fun unsafe cusparseHpruneDense2csrByPercentage as hpruneDense2csrByPercentage { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Half', `Int', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneCsr2csrByPercentage_bufferSizeExt #-}
+{# fun unsafe cusparseSpruneCsr2csrByPercentage_bufferSizeExt as spruneCsr2csrByPercentage_bufferSizeExt { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneCsr2csrByPercentage_bufferSizeExt #-}
+{# fun unsafe cusparseDpruneCsr2csrByPercentage_bufferSizeExt as dpruneCsr2csrByPercentage_bufferSizeExt { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneCsr2csrByPercentage_bufferSizeExt #-}
+{# fun unsafe cusparseHpruneCsr2csrByPercentage_bufferSizeExt as hpruneCsr2csrByPercentage_bufferSizeExt { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneCsr2csrNnzByPercentage #-}
+{# fun unsafe cusparseSpruneCsr2csrNnzByPercentage as spruneCsr2csrNnzByPercentage { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneCsr2csrNnzByPercentage #-}
+{# fun unsafe cusparseDpruneCsr2csrNnzByPercentage as dpruneCsr2csrNnzByPercentage { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneCsr2csrNnzByPercentage #-}
+{# fun unsafe cusparseHpruneCsr2csrNnzByPercentage as hpruneCsr2csrNnzByPercentage { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE spruneCsr2csrByPercentage #-}
+{# fun unsafe cusparseSpruneCsr2csrByPercentage as spruneCsr2csrByPercentage { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dpruneCsr2csrByPercentage #-}
+{# fun unsafe cusparseDpruneCsr2csrByPercentage as dpruneCsr2csrByPercentage { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE hpruneCsr2csrByPercentage #-}
+{# fun unsafe cusparseHpruneCsr2csrByPercentage as hpruneCsr2csrByPercentage { useHandle `Handle', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', CFloat `Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Half', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useInfo_prune `Info_prune', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE snnz_compress #-}
+{# fun unsafe cusparseSnnz_compress as snnz_compress { useHandle `Handle', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Int32', CFloat `Float' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dnnz_compress #-}
+{# fun unsafe cusparseDnnz_compress as dnnz_compress { useHandle `Handle', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Int32', CDouble `Double' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cnnz_compress #-}
+{# fun unsafe cusparseCnnz_compress as cnnz_compress { useHandle `Handle', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Int32', withComplex* `(Complex Float)' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE znnz_compress #-}
+{# fun unsafe cusparseZnnz_compress as znnz_compress { useHandle `Handle', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Int32', withComplex* `(Complex Double)' } -> `()' checkStatus*- #}
+#else
+
+spruneDense2csr_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Float -> Int -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+spruneDense2csr_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneDense2csr_bufferSizeExt' requires at least cuda-9.0"
+
+dpruneDense2csr_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Double -> Int -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+dpruneDense2csr_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneDense2csr_bufferSizeExt' requires at least cuda-9.0"
+
+hpruneDense2csr_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Half -> Int -> Ptr Half -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+hpruneDense2csr_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneDense2csr_bufferSizeExt' requires at least cuda-9.0"
+
+spruneDense2csrNnz :: Handle -> Int -> Int -> DevicePtr Float -> Int -> Ptr Float -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int32 -> DevicePtr () -> IO ()
+spruneDense2csrNnz _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneDense2csrNnz' requires at least cuda-9.0"
+
+dpruneDense2csrNnz :: Handle -> Int -> Int -> DevicePtr Double -> Int -> Ptr Double -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int32 -> DevicePtr () -> IO ()
+dpruneDense2csrNnz _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneDense2csrNnz' requires at least cuda-9.0"
+
+hpruneDense2csrNnz :: Handle -> Int -> Int -> DevicePtr Half -> Int -> Ptr Half -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int32 -> DevicePtr () -> IO ()
+hpruneDense2csrNnz _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneDense2csrNnz' requires at least cuda-9.0"
+
+spruneDense2csr :: Handle -> Int -> Int -> DevicePtr Float -> Int -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+spruneDense2csr _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneDense2csr' requires at least cuda-9.0"
+
+dpruneDense2csr :: Handle -> Int -> Int -> DevicePtr Double -> Int -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+dpruneDense2csr _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneDense2csr' requires at least cuda-9.0"
+
+hpruneDense2csr :: Handle -> Int -> Int -> DevicePtr Half -> Int -> Ptr Half -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+hpruneDense2csr _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneDense2csr' requires at least cuda-9.0"
+
+spruneCsr2csr_bufferSizeExt :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+spruneCsr2csr_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneCsr2csr_bufferSizeExt' requires at least cuda-9.0"
+
+dpruneCsr2csr_bufferSizeExt :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+dpruneCsr2csr_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneCsr2csr_bufferSizeExt' requires at least cuda-9.0"
+
+hpruneCsr2csr_bufferSizeExt :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Half -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+hpruneCsr2csr_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneCsr2csr_bufferSizeExt' requires at least cuda-9.0"
+
+spruneCsr2csrNnz :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> Ptr Int32 -> DevicePtr () -> IO ()
+spruneCsr2csrNnz _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneCsr2csrNnz' requires at least cuda-9.0"
+
+dpruneCsr2csrNnz :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> Ptr Int32 -> DevicePtr () -> IO ()
+dpruneCsr2csrNnz _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneCsr2csrNnz' requires at least cuda-9.0"
+
+hpruneCsr2csrNnz :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Half -> MatrixDescriptor -> DevicePtr Half -> Ptr Int32 -> DevicePtr () -> IO ()
+hpruneCsr2csrNnz _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneCsr2csrNnz' requires at least cuda-9.0"
+
+spruneCsr2csr :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+spruneCsr2csr _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneCsr2csr' requires at least cuda-9.0"
+
+dpruneCsr2csr :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+dpruneCsr2csr _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneCsr2csr' requires at least cuda-9.0"
+
+hpruneCsr2csr :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Half -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+hpruneCsr2csr _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneCsr2csr' requires at least cuda-9.0"
+
+spruneDense2csrByPercentage_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Float -> Int -> Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> Int -> IO ()
+spruneDense2csrByPercentage_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneDense2csrByPercentage_bufferSizeExt' requires at least cuda-9.0"
+
+dpruneDense2csrByPercentage_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Double -> Int -> Float -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> Int -> IO ()
+dpruneDense2csrByPercentage_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneDense2csrByPercentage_bufferSizeExt' requires at least cuda-9.0"
+
+hpruneDense2csrByPercentage_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Half -> Int -> Float -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> Int -> IO ()
+hpruneDense2csrByPercentage_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneDense2csrByPercentage_bufferSizeExt' requires at least cuda-9.0"
+
+spruneDense2csrNnzByPercentage :: Handle -> Int -> Int -> DevicePtr Float -> Int -> Float -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int32 -> Info_prune -> DevicePtr () -> IO ()
+spruneDense2csrNnzByPercentage _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneDense2csrNnzByPercentage' requires at least cuda-9.0"
+
+dpruneDense2csrNnzByPercentage :: Handle -> Int -> Int -> DevicePtr Double -> Int -> Float -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int32 -> Info_prune -> DevicePtr () -> IO ()
+dpruneDense2csrNnzByPercentage _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneDense2csrNnzByPercentage' requires at least cuda-9.0"
+
+hpruneDense2csrNnzByPercentage :: Handle -> Int -> Int -> DevicePtr Half -> Int -> Float -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int32 -> Info_prune -> DevicePtr () -> IO ()
+hpruneDense2csrNnzByPercentage _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneDense2csrNnzByPercentage' requires at least cuda-9.0"
+
+spruneDense2csrByPercentage :: Handle -> Int -> Int -> DevicePtr Float -> Int -> Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> DevicePtr () -> IO ()
+spruneDense2csrByPercentage _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneDense2csrByPercentage' requires at least cuda-9.0"
+
+dpruneDense2csrByPercentage :: Handle -> Int -> Int -> DevicePtr Double -> Int -> Float -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> DevicePtr () -> IO ()
+dpruneDense2csrByPercentage _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneDense2csrByPercentage' requires at least cuda-9.0"
+
+hpruneDense2csrByPercentage :: Handle -> Int -> Int -> DevicePtr Half -> Int -> Float -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> DevicePtr () -> IO ()
+hpruneDense2csrByPercentage _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneDense2csrByPercentage' requires at least cuda-9.0"
+
+spruneCsr2csrByPercentage_bufferSizeExt :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> Int -> IO ()
+spruneCsr2csrByPercentage_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneCsr2csrByPercentage_bufferSizeExt' requires at least cuda-9.0"
+
+dpruneCsr2csrByPercentage_bufferSizeExt :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> Int -> IO ()
+dpruneCsr2csrByPercentage_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneCsr2csrByPercentage_bufferSizeExt' requires at least cuda-9.0"
+
+hpruneCsr2csrByPercentage_bufferSizeExt :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> Int -> IO ()
+hpruneCsr2csrByPercentage_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneCsr2csrByPercentage_bufferSizeExt' requires at least cuda-9.0"
+
+spruneCsr2csrNnzByPercentage :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int -> Info_prune -> DevicePtr () -> IO ()
+spruneCsr2csrNnzByPercentage _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneCsr2csrNnzByPercentage' requires at least cuda-9.0"
+
+dpruneCsr2csrNnzByPercentage :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int -> Info_prune -> DevicePtr () -> IO ()
+dpruneCsr2csrNnzByPercentage _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneCsr2csrNnzByPercentage' requires at least cuda-9.0"
+
+hpruneCsr2csrNnzByPercentage :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int -> Info_prune -> DevicePtr () -> IO ()
+hpruneCsr2csrNnzByPercentage _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneCsr2csrNnzByPercentage' requires at least cuda-9.0"
+
+spruneCsr2csrByPercentage :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> DevicePtr () -> IO ()
+spruneCsr2csrByPercentage _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'spruneCsr2csrByPercentage' requires at least cuda-9.0"
+
+dpruneCsr2csrByPercentage :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> DevicePtr () -> IO ()
+dpruneCsr2csrByPercentage _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dpruneCsr2csrByPercentage' requires at least cuda-9.0"
+
+hpruneCsr2csrByPercentage :: Handle -> Int -> Int -> Int -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Float -> MatrixDescriptor -> DevicePtr Half -> DevicePtr Int32 -> DevicePtr Int32 -> Info_prune -> DevicePtr () -> IO ()
+hpruneCsr2csrByPercentage _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'hpruneCsr2csrByPercentage' requires at least cuda-9.0"
+
+snnz_compress :: Handle -> Int -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Int32 -> Float -> IO ()
+snnz_compress _ _ _ _ _ _ _ _ = cusparseError "'snnz_compress' requires at least cuda-9.0"
+
+dnnz_compress :: Handle -> Int -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Int32 -> Double -> IO ()
+dnnz_compress _ _ _ _ _ _ _ _ = cusparseError "'dnnz_compress' requires at least cuda-9.0"
+
+cnnz_compress :: Handle -> Int -> MatrixDescriptor -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Int32 -> (Complex Float) -> IO ()
+cnnz_compress _ _ _ _ _ _ _ _ = cusparseError "'cnnz_compress' requires at least cuda-9.0"
+
+znnz_compress :: Handle -> Int -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Int32 -> (Complex Double) -> IO ()
+znnz_compress _ _ _ _ _ _ _ _ = cusparseError "'znnz_compress' requires at least cuda-9.0"
 #endif
diff --git a/Foreign/CUDA/BLAS/Sparse/Level3.chs b/Foreign/CUDA/BLAS/Sparse/Level3.chs
--- a/Foreign/CUDA/BLAS/Sparse/Level3.chs
+++ b/Foreign/CUDA/BLAS/Sparse/Level3.chs
@@ -28,6 +28,7 @@
   Info,
   Info_bsrsm2,
   Info_csrgemm2,
+  Info_csrsm2,
   scsrmm,
   dcsrmm,
   ccsrmm,
@@ -80,6 +81,32 @@
   dcsrgemm2,
   ccsrgemm2,
   zcsrgemm2,
+  scsrsm2_bufferSizeExt,
+  dcsrsm2_bufferSizeExt,
+  ccsrsm2_bufferSizeExt,
+  zcsrsm2_bufferSizeExt,
+  scsrsm2_analysis,
+  dcsrsm2_analysis,
+  ccsrsm2_analysis,
+  zcsrsm2_analysis,
+  scsrsm2_solve,
+  dcsrsm2_solve,
+  ccsrsm2_solve,
+  zcsrsm2_solve,
+  xcsrsm2_zeroPivot,
+  sgemmi,
+  dgemmi,
+  cgemmi,
+  zgemmi,
+  xcsrgeam2Nnz,
+  scsrgeam2_bufferSizeExt,
+  dcsrgeam2_bufferSizeExt,
+  ccsrgeam2_bufferSizeExt,
+  zcsrgeam2_bufferSizeExt,
+  scsrgeam2,
+  dcsrgeam2,
+  ccsrgeam2,
+  zcsrgeam2,
 
 ) where
 
@@ -182,16 +209,16 @@
 {# fun unsafe cusparseZbsrsm2_bufferSize as zbsrsm2_bufferSize { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
 
 {-# INLINEABLE sbsrsm2_analysis #-}
-{# fun unsafe cusparseSbsrsm2_analysis as sbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', castPtr `Ptr ()' } -> `()' checkStatus*- #}
+{# fun unsafe cusparseSbsrsm2_analysis as sbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
 
 {-# INLINEABLE dbsrsm2_analysis #-}
-{# fun unsafe cusparseDbsrsm2_analysis as dbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', castPtr `Ptr ()' } -> `()' checkStatus*- #}
+{# fun unsafe cusparseDbsrsm2_analysis as dbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
 
 {-# INLINEABLE cbsrsm2_analysis #-}
-{# fun unsafe cusparseCbsrsm2_analysis as cbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', castPtr `Ptr ()' } -> `()' checkStatus*- #}
+{# fun unsafe cusparseCbsrsm2_analysis as cbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
 
 {-# INLINEABLE zbsrsm2_analysis #-}
-{# fun unsafe cusparseZbsrsm2_analysis as zbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', castPtr `Ptr ()' } -> `()' checkStatus*- #}
+{# fun unsafe cusparseZbsrsm2_analysis as zbsrsm2_analysis { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
 
 {-# INLINEABLE sbsrsm2_solve #-}
 {# fun unsafe cusparseSbsrsm2_solve as sbsrsm2_solve { useHandle `Handle', cFromEnum `Direction', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', `Int', useInfo_bsrsm2 `Info_bsrsm2', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', `Int', cFromEnum `Policy', castPtr `Ptr ()' } -> `()' checkStatus*- #}
@@ -293,4 +320,163 @@
 
 zcsrgemm2 :: Handle -> Int -> Int -> Int -> Ptr (Complex Double) -> MatrixDescriptor -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr (Complex Double) -> MatrixDescriptor -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Info_csrgemm2 -> DevicePtr () -> IO ()
 zcsrgemm2 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zcsrgemm2' requires at least cuda-7.0"
+#endif
+#if CUDA_VERSION >= 9020
+
+{-# INLINEABLE scsrsm2_bufferSizeExt #-}
+{# fun unsafe cusparseScsrsm2_bufferSizeExt as scsrsm2_bufferSizeExt { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr Float', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dcsrsm2_bufferSizeExt #-}
+{# fun unsafe cusparseDcsrsm2_bufferSizeExt as dcsrsm2_bufferSizeExt { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr Double', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE ccsrsm2_bufferSizeExt #-}
+{# fun unsafe cusparseCcsrsm2_bufferSizeExt as ccsrsm2_bufferSizeExt { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr (Complex Float)', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zcsrsm2_bufferSizeExt #-}
+{# fun unsafe cusparseZcsrsm2_bufferSizeExt as zcsrsm2_bufferSizeExt { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr (Complex Double)', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE scsrsm2_analysis #-}
+{# fun unsafe cusparseScsrsm2_analysis as scsrsm2_analysis { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr Float', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dcsrsm2_analysis #-}
+{# fun unsafe cusparseDcsrsm2_analysis as dcsrsm2_analysis { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr Double', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE ccsrsm2_analysis #-}
+{# fun unsafe cusparseCcsrsm2_analysis as ccsrsm2_analysis { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr (Complex Float)', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zcsrsm2_analysis #-}
+{# fun unsafe cusparseZcsrsm2_analysis as zcsrsm2_analysis { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr (Complex Double)', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE scsrsm2_solve #-}
+{# fun unsafe cusparseScsrsm2_solve as scsrsm2_solve { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr Float', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dcsrsm2_solve #-}
+{# fun unsafe cusparseDcsrsm2_solve as dcsrsm2_solve { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr Double', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE ccsrsm2_solve #-}
+{# fun unsafe cusparseCcsrsm2_solve as ccsrsm2_solve { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr (Complex Float)', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zcsrsm2_solve #-}
+{# fun unsafe cusparseZcsrsm2_solve as zcsrsm2_solve { useHandle `Handle', `Int', cFromEnum `Operation', cFromEnum `Operation', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr (Complex Double)', `Int', useInfo_csrsm2 `Info_csrsm2', cFromEnum `Policy', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE xcsrsm2_zeroPivot #-}
+{# fun unsafe cusparseXcsrsm2_zeroPivot as xcsrsm2_zeroPivot { useHandle `Handle', useInfo_csrsm2 `Info_csrsm2', castPtr `Ptr Int32' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgemmi #-}
+{# fun unsafe cusparseSgemmi as sgemmi { useHandle `Handle', `Int', `Int', `Int', `Int', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Float', useDevP `DevicePtr Float', `Int' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgemmi #-}
+{# fun unsafe cusparseDgemmi as dgemmi { useHandle `Handle', `Int', `Int', `Int', `Int', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Double', useDevP `DevicePtr Double', `Int' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgemmi #-}
+{# fun unsafe cusparseCgemmi as cgemmi { useHandle `Handle', `Int', `Int', `Int', `Int', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgemmi #-}
+{# fun unsafe cusparseZgemmi as zgemmi { useHandle `Handle', `Int', `Int', `Int', `Int', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE xcsrgeam2Nnz #-}
+{# fun unsafe cusparseXcsrgeam2Nnz as xcsrgeam2Nnz { useHandle `Handle', `Int', `Int', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Int32', castPtr `Ptr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE scsrgeam2_bufferSizeExt #-}
+{# fun unsafe cusparseScsrgeam2_bufferSizeExt as scsrgeam2_bufferSizeExt { useHandle `Handle', `Int', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dcsrgeam2_bufferSizeExt #-}
+{# fun unsafe cusparseDcsrgeam2_bufferSizeExt as dcsrgeam2_bufferSizeExt { useHandle `Handle', `Int', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE ccsrgeam2_bufferSizeExt #-}
+{# fun unsafe cusparseCcsrgeam2_bufferSizeExt as ccsrgeam2_bufferSizeExt { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Float)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr (Complex Float)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zcsrgeam2_bufferSizeExt #-}
+{# fun unsafe cusparseZcsrgeam2_bufferSizeExt as zcsrgeam2_bufferSizeExt { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Double)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr (Complex Double)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE scsrgeam2 #-}
+{# fun unsafe cusparseScsrgeam2 as scsrgeam2 { useHandle `Handle', `Int', `Int', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Float', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Float', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dcsrgeam2 #-}
+{# fun unsafe cusparseDcsrgeam2 as dcsrgeam2 { useHandle `Handle', `Int', `Int', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr Double', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr Double', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE ccsrgeam2 #-}
+{# fun unsafe cusparseCcsrgeam2 as ccsrgeam2 { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Float)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr (Complex Float)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zcsrgeam2 #-}
+{# fun unsafe cusparseZcsrgeam2 as zcsrgeam2 { useHandle `Handle', `Int', `Int', castPtr `Ptr (Complex Double)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', castPtr `Ptr (Complex Double)', useMatDescr `MatrixDescriptor', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useMatDescr `MatrixDescriptor', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr Int32', useDevP `DevicePtr Int32', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+#else
+
+scsrsm2_bufferSizeExt :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr Float -> Int -> Info_csrsm2 -> Policy -> Int -> IO ()
+scsrsm2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'scsrsm2_bufferSizeExt' requires at least cuda-9.0"
+
+dcsrsm2_bufferSizeExt :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr Double -> Int -> Info_csrsm2 -> Policy -> Int -> IO ()
+dcsrsm2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dcsrsm2_bufferSizeExt' requires at least cuda-9.0"
+
+ccsrsm2_bufferSizeExt :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Float) -> MatrixDescriptor -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr (Complex Float) -> Int -> Info_csrsm2 -> Policy -> Int -> IO ()
+ccsrsm2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'ccsrsm2_bufferSizeExt' requires at least cuda-9.0"
+
+zcsrsm2_bufferSizeExt :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Double) -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr (Complex Double) -> Int -> Info_csrsm2 -> Policy -> Int -> IO ()
+zcsrsm2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zcsrsm2_bufferSizeExt' requires at least cuda-9.0"
+
+scsrsm2_analysis :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr Float -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+scsrsm2_analysis _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'scsrsm2_analysis' requires at least cuda-9.0"
+
+dcsrsm2_analysis :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr Double -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+dcsrsm2_analysis _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dcsrsm2_analysis' requires at least cuda-9.0"
+
+ccsrsm2_analysis :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Float) -> MatrixDescriptor -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr (Complex Float) -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+ccsrsm2_analysis _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'ccsrsm2_analysis' requires at least cuda-9.0"
+
+zcsrsm2_analysis :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Double) -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr (Complex Double) -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+zcsrsm2_analysis _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zcsrsm2_analysis' requires at least cuda-9.0"
+
+scsrsm2_solve :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr Float -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr Float -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+scsrsm2_solve _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'scsrsm2_solve' requires at least cuda-9.0"
+
+dcsrsm2_solve :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr Double -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr Double -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+dcsrsm2_solve _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dcsrsm2_solve' requires at least cuda-9.0"
+
+ccsrsm2_solve :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Float) -> MatrixDescriptor -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr (Complex Float) -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+ccsrsm2_solve _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'ccsrsm2_solve' requires at least cuda-9.0"
+
+zcsrsm2_solve :: Handle -> Int -> Operation -> Operation -> Int -> Int -> Int -> Ptr (Complex Double) -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr (Complex Double) -> Int -> Info_csrsm2 -> Policy -> DevicePtr () -> IO ()
+zcsrsm2_solve _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zcsrsm2_solve' requires at least cuda-9.0"
+
+xcsrsm2_zeroPivot :: Handle -> Info_csrsm2 -> Ptr Int32 -> IO ()
+xcsrsm2_zeroPivot _ _ _ = cusparseError "'xcsrsm2_zeroPivot' requires at least cuda-9.0"
+
+sgemmi :: Handle -> Int -> Int -> Int -> Int -> Ptr Float -> DevicePtr Float -> Int -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Float -> DevicePtr Float -> Int -> IO ()
+sgemmi _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'sgemmi' requires at least cuda-9.0"
+
+dgemmi :: Handle -> Int -> Int -> Int -> Int -> Ptr Double -> DevicePtr Double -> Int -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Double -> DevicePtr Double -> Int -> IO ()
+dgemmi _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dgemmi' requires at least cuda-9.0"
+
+cgemmi :: Handle -> Int -> Int -> Int -> Int -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr (Complex Float) -> DevicePtr (Complex Float) -> Int -> IO ()
+cgemmi _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'cgemmi' requires at least cuda-9.0"
+
+zgemmi :: Handle -> Int -> Int -> Int -> Int -> Ptr (Complex Double) -> DevicePtr (Complex Double) -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr (Complex Double) -> DevicePtr (Complex Double) -> Int -> IO ()
+zgemmi _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zgemmi' requires at least cuda-9.0"
+
+xcsrgeam2Nnz :: Handle -> Int -> Int -> MatrixDescriptor -> Int -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> Int -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr Int32 -> Ptr Int32 -> DevicePtr () -> IO ()
+xcsrgeam2Nnz _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'xcsrgeam2Nnz' requires at least cuda-9.0"
+
+scsrgeam2_bufferSizeExt :: Handle -> Int -> Int -> Ptr Float -> MatrixDescriptor -> Int -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Float -> MatrixDescriptor -> Int -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+scsrgeam2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'scsrgeam2_bufferSizeExt' requires at least cuda-9.0"
+
+dcsrgeam2_bufferSizeExt :: Handle -> Int -> Int -> Ptr Double -> MatrixDescriptor -> Int -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Double -> MatrixDescriptor -> Int -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+dcsrgeam2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dcsrgeam2_bufferSizeExt' requires at least cuda-9.0"
+
+ccsrgeam2_bufferSizeExt :: Handle -> Int -> Int -> Ptr (Complex Float) -> MatrixDescriptor -> Int -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr (Complex Float) -> MatrixDescriptor -> Int -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+ccsrgeam2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'ccsrgeam2_bufferSizeExt' requires at least cuda-9.0"
+
+zcsrgeam2_bufferSizeExt :: Handle -> Int -> Int -> Ptr (Complex Double) -> MatrixDescriptor -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr (Complex Double) -> MatrixDescriptor -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Int -> IO ()
+zcsrgeam2_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zcsrgeam2_bufferSizeExt' requires at least cuda-9.0"
+
+scsrgeam2 :: Handle -> Int -> Int -> Ptr Float -> MatrixDescriptor -> Int -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Float -> MatrixDescriptor -> Int -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr Float -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+scsrgeam2 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'scsrgeam2' requires at least cuda-9.0"
+
+dcsrgeam2 :: Handle -> Int -> Int -> Ptr Double -> MatrixDescriptor -> Int -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr Double -> MatrixDescriptor -> Int -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr Double -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+dcsrgeam2 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dcsrgeam2' requires at least cuda-9.0"
+
+ccsrgeam2 :: Handle -> Int -> Int -> Ptr (Complex Float) -> MatrixDescriptor -> Int -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr (Complex Float) -> MatrixDescriptor -> Int -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr (Complex Float) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+ccsrgeam2 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'ccsrgeam2' requires at least cuda-9.0"
+
+zcsrgeam2 :: Handle -> Int -> Int -> Ptr (Complex Double) -> MatrixDescriptor -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> Ptr (Complex Double) -> MatrixDescriptor -> Int -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> MatrixDescriptor -> DevicePtr (Complex Double) -> DevicePtr Int32 -> DevicePtr Int32 -> DevicePtr () -> IO ()
+zcsrgeam2 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zcsrgeam2' requires at least cuda-9.0"
 #endif
diff --git a/Foreign/CUDA/BLAS/Sparse/Precondition.chs b/Foreign/CUDA/BLAS/Sparse/Precondition.chs
--- a/Foreign/CUDA/BLAS/Sparse/Precondition.chs
+++ b/Foreign/CUDA/BLAS/Sparse/Precondition.chs
@@ -112,6 +112,46 @@
   cgtsvStridedBatch,
   zgtsvStridedBatch,
   csrilu0Ex,
+  sgtsv2_bufferSizeExt,
+  dgtsv2_bufferSizeExt,
+  cgtsv2_bufferSizeExt,
+  zgtsv2_bufferSizeExt,
+  sgtsv2,
+  dgtsv2,
+  cgtsv2,
+  zgtsv2,
+  sgtsv2_nopivot_bufferSizeExt,
+  dgtsv2_nopivot_bufferSizeExt,
+  cgtsv2_nopivot_bufferSizeExt,
+  zgtsv2_nopivot_bufferSizeExt,
+  sgtsv2_nopivot,
+  dgtsv2_nopivot,
+  cgtsv2_nopivot,
+  zgtsv2_nopivot,
+  sgtsv2StridedBatch_bufferSizeExt,
+  dgtsv2StridedBatch_bufferSizeExt,
+  cgtsv2StridedBatch_bufferSizeExt,
+  zgtsv2StridedBatch_bufferSizeExt,
+  sgtsv2StridedBatch,
+  dgtsv2StridedBatch,
+  cgtsv2StridedBatch,
+  zgtsv2StridedBatch,
+  sgtsvInterleavedBatch_bufferSizeExt,
+  dgtsvInterleavedBatch_bufferSizeExt,
+  cgtsvInterleavedBatch_bufferSizeExt,
+  zgtsvInterleavedBatch_bufferSizeExt,
+  sgtsvInterleavedBatch,
+  dgtsvInterleavedBatch,
+  cgtsvInterleavedBatch,
+  zgtsvInterleavedBatch,
+  sgpsvInterleavedBatch_bufferSizeExt,
+  dgpsvInterleavedBatch_bufferSizeExt,
+  cgpsvInterleavedBatch_bufferSizeExt,
+  zgpsvInterleavedBatch_bufferSizeExt,
+  sgpsvInterleavedBatch,
+  dgpsvInterleavedBatch,
+  cgpsvInterleavedBatch,
+  zgpsvInterleavedBatch,
 
 ) where
 
@@ -388,4 +428,250 @@
 
 csrilu0Ex :: Handle -> Operation -> Int -> MatrixDescriptor -> DevicePtr () -> Type -> DevicePtr Int32 -> DevicePtr Int32 -> Info -> Type -> IO ()
 csrilu0Ex _ _ _ _ _ _ _ _ _ _ = cusparseError "'csrilu0Ex' requires at least cuda-8.0"
+#endif
+#if CUDA_VERSION >= 9000
+
+{-# INLINEABLE sgtsv2_bufferSizeExt #-}
+{# fun unsafe cusparseSgtsv2_bufferSizeExt as sgtsv2_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsv2_bufferSizeExt #-}
+{# fun unsafe cusparseDgtsv2_bufferSizeExt as dgtsv2_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsv2_bufferSizeExt #-}
+{# fun unsafe cusparseCgtsv2_bufferSizeExt as cgtsv2_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsv2_bufferSizeExt #-}
+{# fun unsafe cusparseZgtsv2_bufferSizeExt as zgtsv2_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgtsv2 #-}
+{# fun unsafe cusparseSgtsv2 as sgtsv2 { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsv2 #-}
+{# fun unsafe cusparseDgtsv2 as dgtsv2 { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsv2 #-}
+{# fun unsafe cusparseCgtsv2 as cgtsv2 { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsv2 #-}
+{# fun unsafe cusparseZgtsv2 as zgtsv2 { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgtsv2_nopivot_bufferSizeExt #-}
+{# fun unsafe cusparseSgtsv2_nopivot_bufferSizeExt as sgtsv2_nopivot_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsv2_nopivot_bufferSizeExt #-}
+{# fun unsafe cusparseDgtsv2_nopivot_bufferSizeExt as dgtsv2_nopivot_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsv2_nopivot_bufferSizeExt #-}
+{# fun unsafe cusparseCgtsv2_nopivot_bufferSizeExt as cgtsv2_nopivot_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsv2_nopivot_bufferSizeExt #-}
+{# fun unsafe cusparseZgtsv2_nopivot_bufferSizeExt as zgtsv2_nopivot_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgtsv2_nopivot #-}
+{# fun unsafe cusparseSgtsv2_nopivot as sgtsv2_nopivot { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsv2_nopivot #-}
+{# fun unsafe cusparseDgtsv2_nopivot as dgtsv2_nopivot { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsv2_nopivot #-}
+{# fun unsafe cusparseCgtsv2_nopivot as cgtsv2_nopivot { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsv2_nopivot #-}
+{# fun unsafe cusparseZgtsv2_nopivot as zgtsv2_nopivot { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgtsv2StridedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseSgtsv2StridedBatch_bufferSizeExt as sgtsv2StridedBatch_bufferSizeExt { useHandle `Handle', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsv2StridedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseDgtsv2StridedBatch_bufferSizeExt as dgtsv2StridedBatch_bufferSizeExt { useHandle `Handle', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsv2StridedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseCgtsv2StridedBatch_bufferSizeExt as cgtsv2StridedBatch_bufferSizeExt { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsv2StridedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseZgtsv2StridedBatch_bufferSizeExt as zgtsv2StridedBatch_bufferSizeExt { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgtsv2StridedBatch #-}
+{# fun unsafe cusparseSgtsv2StridedBatch as sgtsv2StridedBatch { useHandle `Handle', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsv2StridedBatch #-}
+{# fun unsafe cusparseDgtsv2StridedBatch as dgtsv2StridedBatch { useHandle `Handle', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsv2StridedBatch #-}
+{# fun unsafe cusparseCgtsv2StridedBatch as cgtsv2StridedBatch { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsv2StridedBatch #-}
+{# fun unsafe cusparseZgtsv2StridedBatch as zgtsv2StridedBatch { useHandle `Handle', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+#else
+
+sgtsv2_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> Int -> IO ()
+sgtsv2_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsv2_bufferSizeExt' requires at least cuda-9.0"
+
+dgtsv2_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> Int -> IO ()
+dgtsv2_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsv2_bufferSizeExt' requires at least cuda-9.0"
+
+cgtsv2_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int -> IO ()
+cgtsv2_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsv2_bufferSizeExt' requires at least cuda-9.0"
+
+zgtsv2_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int -> IO ()
+zgtsv2_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsv2_bufferSizeExt' requires at least cuda-9.0"
+
+sgtsv2 :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> DevicePtr () -> IO ()
+sgtsv2 _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsv2' requires at least cuda-9.0"
+
+dgtsv2 :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> DevicePtr () -> IO ()
+dgtsv2 _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsv2' requires at least cuda-9.0"
+
+cgtsv2 :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> DevicePtr () -> IO ()
+cgtsv2 _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsv2' requires at least cuda-9.0"
+
+zgtsv2 :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> DevicePtr () -> IO ()
+zgtsv2 _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsv2' requires at least cuda-9.0"
+
+sgtsv2_nopivot_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> Int -> IO ()
+sgtsv2_nopivot_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsv2_nopivot_bufferSizeExt' requires at least cuda-9.0"
+
+dgtsv2_nopivot_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> Int -> IO ()
+dgtsv2_nopivot_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsv2_nopivot_bufferSizeExt' requires at least cuda-9.0"
+
+cgtsv2_nopivot_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int -> IO ()
+cgtsv2_nopivot_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsv2_nopivot_bufferSizeExt' requires at least cuda-9.0"
+
+zgtsv2_nopivot_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int -> IO ()
+zgtsv2_nopivot_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsv2_nopivot_bufferSizeExt' requires at least cuda-9.0"
+
+sgtsv2_nopivot :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> DevicePtr () -> IO ()
+sgtsv2_nopivot _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsv2_nopivot' requires at least cuda-9.0"
+
+dgtsv2_nopivot :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> DevicePtr () -> IO ()
+dgtsv2_nopivot _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsv2_nopivot' requires at least cuda-9.0"
+
+cgtsv2_nopivot :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> DevicePtr () -> IO ()
+cgtsv2_nopivot _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsv2_nopivot' requires at least cuda-9.0"
+
+zgtsv2_nopivot :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> DevicePtr () -> IO ()
+zgtsv2_nopivot _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsv2_nopivot' requires at least cuda-9.0"
+
+sgtsv2StridedBatch_bufferSizeExt :: Handle -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> Int -> Int -> IO ()
+sgtsv2StridedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsv2StridedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+dgtsv2StridedBatch_bufferSizeExt :: Handle -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> Int -> Int -> IO ()
+dgtsv2StridedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsv2StridedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+cgtsv2StridedBatch_bufferSizeExt :: Handle -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int -> Int -> IO ()
+cgtsv2StridedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsv2StridedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+zgtsv2StridedBatch_bufferSizeExt :: Handle -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int -> Int -> IO ()
+zgtsv2StridedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsv2StridedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+sgtsv2StridedBatch :: Handle -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> Int -> DevicePtr () -> IO ()
+sgtsv2StridedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsv2StridedBatch' requires at least cuda-9.0"
+
+dgtsv2StridedBatch :: Handle -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> Int -> DevicePtr () -> IO ()
+dgtsv2StridedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsv2StridedBatch' requires at least cuda-9.0"
+
+cgtsv2StridedBatch :: Handle -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int -> DevicePtr () -> IO ()
+cgtsv2StridedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsv2StridedBatch' requires at least cuda-9.0"
+
+zgtsv2StridedBatch :: Handle -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int -> DevicePtr () -> IO ()
+zgtsv2StridedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsv2StridedBatch' requires at least cuda-9.0"
+#endif
+#if CUDA_VERSION >= 9020
+
+{-# INLINEABLE sgtsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseSgtsvInterleavedBatch_bufferSizeExt as sgtsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseDgtsvInterleavedBatch_bufferSizeExt as dgtsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseCgtsvInterleavedBatch_bufferSizeExt as cgtsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseZgtsvInterleavedBatch_bufferSizeExt as zgtsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgtsvInterleavedBatch #-}
+{# fun unsafe cusparseSgtsvInterleavedBatch as sgtsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgtsvInterleavedBatch #-}
+{# fun unsafe cusparseDgtsvInterleavedBatch as dgtsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgtsvInterleavedBatch #-}
+{# fun unsafe cusparseCgtsvInterleavedBatch as cgtsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgtsvInterleavedBatch #-}
+{# fun unsafe cusparseZgtsvInterleavedBatch as zgtsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgpsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseSgpsvInterleavedBatch_bufferSizeExt as sgpsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgpsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseDgpsvInterleavedBatch_bufferSizeExt as dgpsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgpsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseCgpsvInterleavedBatch_bufferSizeExt as cgpsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgpsvInterleavedBatch_bufferSizeExt #-}
+{# fun unsafe cusparseZgpsvInterleavedBatch_bufferSizeExt as zgpsvInterleavedBatch_bufferSizeExt { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', alloca- `Int' peekIntConv* } -> `()' checkStatus*- #}
+
+{-# INLINEABLE sgpsvInterleavedBatch #-}
+{# fun unsafe cusparseSgpsvInterleavedBatch as sgpsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', useDevP `DevicePtr Float', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE dgpsvInterleavedBatch #-}
+{# fun unsafe cusparseDgpsvInterleavedBatch as dgpsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', useDevP `DevicePtr Double', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE cgpsvInterleavedBatch #-}
+{# fun unsafe cusparseCgpsvInterleavedBatch as cgpsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', useDevP `DevicePtr (Complex Float)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+
+{-# INLINEABLE zgpsvInterleavedBatch #-}
+{# fun unsafe cusparseZgpsvInterleavedBatch as zgpsvInterleavedBatch { useHandle `Handle', `Int', `Int', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', useDevP `DevicePtr (Complex Double)', `Int', useDevP `DevicePtr ()' } -> `()' checkStatus*- #}
+#else
+
+sgtsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> Int -> IO ()
+sgtsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+dgtsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> Int -> IO ()
+dgtsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+cgtsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int -> IO ()
+cgtsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+zgtsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int -> IO ()
+zgtsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+sgtsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> DevicePtr () -> IO ()
+sgtsvInterleavedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'sgtsvInterleavedBatch' requires at least cuda-9.0"
+
+dgtsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> DevicePtr () -> IO ()
+dgtsvInterleavedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'dgtsvInterleavedBatch' requires at least cuda-9.0"
+
+cgtsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> DevicePtr () -> IO ()
+cgtsvInterleavedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'cgtsvInterleavedBatch' requires at least cuda-9.0"
+
+zgtsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> DevicePtr () -> IO ()
+zgtsvInterleavedBatch _ _ _ _ _ _ _ _ _ = cusparseError "'zgtsvInterleavedBatch' requires at least cuda-9.0"
+
+sgpsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> Int -> IO ()
+sgpsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'sgpsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+dgpsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> Int -> IO ()
+dgpsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dgpsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+cgpsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> Int -> IO ()
+cgpsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'cgpsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+zgpsvInterleavedBatch_bufferSizeExt :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> Int -> IO ()
+zgpsvInterleavedBatch_bufferSizeExt _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zgpsvInterleavedBatch_bufferSizeExt' requires at least cuda-9.0"
+
+sgpsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> DevicePtr Float -> Int -> DevicePtr () -> IO ()
+sgpsvInterleavedBatch _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'sgpsvInterleavedBatch' requires at least cuda-9.0"
+
+dgpsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> DevicePtr Double -> Int -> DevicePtr () -> IO ()
+dgpsvInterleavedBatch _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'dgpsvInterleavedBatch' requires at least cuda-9.0"
+
+cgpsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> DevicePtr (Complex Float) -> Int -> DevicePtr () -> IO ()
+cgpsvInterleavedBatch _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'cgpsvInterleavedBatch' requires at least cuda-9.0"
+
+zgpsvInterleavedBatch :: Handle -> Int -> Int -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> DevicePtr (Complex Double) -> Int -> DevicePtr () -> IO ()
+zgpsvInterleavedBatch _ _ _ _ _ _ _ _ _ _ _ = cusparseError "'zgpsvInterleavedBatch' requires at least cuda-9.0"
 #endif
diff --git a/cbits/stubs.h b/cbits/stubs.h
--- a/cbits/stubs.h
+++ b/cbits/stubs.h
@@ -14,5 +14,191 @@
 #include <cuda.h>
 #include <cusparse_v2.h>
 
+/*
+ * We need to redeclare these functions, as they are now hidden behind a #if
+ * defined(__cplusplus) guard.
+ */
+#if CUDA_VERSION >= 9010
+typedef struct __align__(2) {
+   unsigned short x;
+} __half;
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csr_bufferSizeExt(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    const __half *A,
+    int lda,
+    const __half *threshold,
+    const cusparseMatDescr_t descrC,
+    const __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    const int *csrSortedColIndC,
+    size_t *pBufferSizeInBytes);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrNnz(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    const __half *A,
+    int lda,
+    const __half *threshold,
+    const cusparseMatDescr_t descrC,
+    int *csrRowPtrC,
+    int *nnzTotalDevHostPtr,
+    void *pBuffer);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csr(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    const __half *A,
+    int lda,
+    const __half *threshold,
+    const cusparseMatDescr_t descrC,
+    __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    int *csrSortedColIndC,
+    void *pBuffer);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csr_bufferSizeExt(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    int nnzA,
+    const cusparseMatDescr_t descrA,
+    const __half *csrSortedValA,
+    const int *csrSortedRowPtrA,
+    const int *csrSortedColIndA,
+    const __half *threshold,
+    const cusparseMatDescr_t descrC,
+    const __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    const int *csrSortedColIndC,
+    size_t *pBufferSizeInBytes);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrNnz(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    int nnzA,
+    const cusparseMatDescr_t descrA,
+    const __half *csrSortedValA,
+    const int *csrSortedRowPtrA,
+    const int *csrSortedColIndA,
+    const __half *threshold,
+    const cusparseMatDescr_t descrC,
+    int *csrSortedRowPtrC,
+    int *nnzTotalDevHostPtr, /* can be on host or device */
+    void *pBuffer);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csr(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    int nnzA,
+    const cusparseMatDescr_t descrA,
+    const __half *csrSortedValA,
+    const int *csrSortedRowPtrA,
+    const int *csrSortedColIndA,
+    const __half *threshold,
+    const cusparseMatDescr_t descrC,
+    __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    int *csrSortedColIndC,
+    void *pBuffer);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrByPercentage_bufferSizeExt(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    const __half *A,
+    int lda,
+    float percentage, /* between 0 to 100 */
+    const cusparseMatDescr_t descrC,
+    const __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    const int *csrSortedColIndC,
+    pruneInfo_t info,
+    size_t *pBufferSizeInBytes);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrNnzByPercentage(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    const __half *A,
+    int lda,
+    float percentage, /* between 0 to 100 */
+    const cusparseMatDescr_t descrC,
+    int *csrRowPtrC,
+    int *nnzTotalDevHostPtr, /* can be on host or device */
+    pruneInfo_t info,
+    void *pBuffer);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneDense2csrByPercentage(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    const __half *A,
+    int lda,
+    float percentage, /* between 0 to 100 */
+    const cusparseMatDescr_t descrC,
+    __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    int *csrSortedColIndC,
+    pruneInfo_t info,
+    void *pBuffer);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrByPercentage_bufferSizeExt(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    int nnzA,
+    const cusparseMatDescr_t descrA,
+    const __half *csrSortedValA,
+    const int *csrSortedRowPtrA,
+    const int *csrSortedColIndA,
+    float percentage, /* between 0 to 100 */
+    const cusparseMatDescr_t descrC,
+    const __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    const int *csrSortedColIndC,
+    pruneInfo_t info,
+    size_t *pBufferSizeInBytes);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrNnzByPercentage(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    int nnzA,
+    const cusparseMatDescr_t descrA,
+    const __half *csrSortedValA,
+    const int *csrSortedRowPtrA,
+    const int *csrSortedColIndA,
+    float percentage, /* between 0 to 100 */
+    const cusparseMatDescr_t descrC,
+    int *csrSortedRowPtrC,
+    int *nnzTotalDevHostPtr, /* can be on host or device */
+    pruneInfo_t info,
+    void *pBuffer);
+
+cusparseStatus_t CUSPARSEAPI cusparseHpruneCsr2csrByPercentage(
+    cusparseHandle_t handle,
+    int m,
+    int n,
+    int nnzA,
+    const cusparseMatDescr_t descrA,
+    const __half *csrSortedValA,
+    const int *csrSortedRowPtrA,
+    const int *csrSortedColIndA,
+    float percentage, /* between 0 to 100 */
+    const cusparseMatDescr_t descrC,
+    __half *csrSortedValC,
+    const int *csrSortedRowPtrC,
+    int *csrSortedColIndC,
+    pruneInfo_t info,
+    void *pBuffer);
+
+#endif /* CUDA_VERSION */
 #endif /* C_STUBS_H */
 
diff --git a/cusparse.cabal b/cusparse.cabal
--- a/cusparse.cabal
+++ b/cusparse.cabal
@@ -1,5 +1,5 @@
 name:                   cusparse
-version:                0.1.0.1
+version:                0.2.0.0
 synopsis:               FFI bindings to the CUDA Sparse BLAS library
 description:
     The cuSPARSE library contains a set of basic linear algebra subroutines for
@@ -17,8 +17,8 @@
 license:                BSD3
 license-file:           LICENSE
 author:                 Trevor L. McDonell
-maintainer:             Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>
-copyright:              Copyright (c) [2017]. Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>
+maintainer:             Trevor L. McDonell <trevor.mcdonell@gmail.com>
+copyright:              Copyright (c) [2017]. Trevor L. McDonell <trevor.mcdonell@gmail.com>
 category:               Foreign
 cabal-version:          >=1.24
 
@@ -86,6 +86,6 @@
 source-repository this
     type:               git
     location:           https://github.com/tmcdonell/cusparse
-    tag:                0.1.0.1
+    tag:                v0.2.0.0
 
 -- vim: nospell